content
stringlengths 228
999k
| pred_label
stringclasses 1
value | pred_score
float64 0.5
1
|
|---|---|---|
0933. Number of Recent Calls
933. Number of Recent Calls #
题目 #
Write a class RecentCounter to count recent requests.
It has only one method: ping(int t), where t represents some time in milliseconds.
Return the number of pings that have been made from 3000 milliseconds ago until now.
Any ping with time in [t - 3000, t] will count, including the current ping.
It is guaranteed that every call to ping uses a strictly larger value of t than before.
Example 1:
Input: inputs = ["RecentCounter","ping","ping","ping","ping"], inputs = [[],[1],[100],[3001],[3002]]
Output: [null,1,2,3,3]
Note:
1. Each test case will have at most 10000 calls to ping.
2. Each test case will call ping with strictly increasing values of t.
3. Each call to ping will have 1 <= t <= 10^9.
题目大意 #
写一个 RecentCounter 类来计算最近的请求。它只有一个方法：ping(int t)，其中 t 代表以毫秒为单位的某个时间。返回从 3000 毫秒前到现在的 ping 数。任何处于 [t - 3000, t] 时间范围之内的 ping 都将会被计算在内，包括当前（指 t 时刻）的 ping。保证每次对 ping 的调用都使用比之前更大的 t 值。 提示：
• 每个测试用例最多调用 10000 次 ping。
• 每个测试用例会使用严格递增的 t 值来调用 ping。
• 每次调用 ping 都有 1 <= t <= 10^9。
解题思路 #
• 要求设计一个类，可以用 ping(t) 的方法，计算 [t-3000, t] 区间内的 ping 数。t 是毫秒。
• 这一题比较简单，ping() 方法用二分搜索即可。
代码 #
type RecentCounter struct {
list []int
}
func Constructor933() RecentCounter {
return RecentCounter{
list: []int{},
}
}
func (this *RecentCounter) Ping(t int) int {
this.list = append(this.list, t)
index := sort.Search(len(this.list), func(i int) bool { return this.list[i] >= t-3000 })
if index < 0 {
index = -index - 1
}
return len(this.list) - index
}
/**
* Your RecentCounter object will be instantiated and called as such:
* obj := Constructor();
* param_1 := obj.Ping(t);
*/
⬅️上一页
下一页➡️
Calendar Sep 11, 2022
Edit Edit this page
本站总访问量: 次 您是本站第 位访问者
|
__label__pos
| 0.968303 |
1 /*
2 * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "cds/archiveHeapLoader.hpp"
27 #include "cds/cdsConfig.hpp"
28 #include "cds/heapShared.hpp"
29 #include "classfile/classLoaderDataShared.hpp"
30 #include "logging/log.hpp"
31
32 bool CDSConfig::_is_dumping_static_archive = false;
33 bool CDSConfig::_is_dumping_dynamic_archive = false;
34
35 // The ability to dump the FMG depends on many factors checked by
36 // is_dumping_full_module_graph(), but can be unconditionally disabled by
37 // _dumping_full_module_graph_disabled. (Ditto for loading the FMG).
38 bool CDSConfig::_dumping_full_module_graph_disabled = false;
39 bool CDSConfig::_loading_full_module_graph_disabled = false;
40
41 #if INCLUDE_CDS_JAVA_HEAP
42 bool CDSConfig::is_dumping_heap() {
43 // heap dump is not supported in dynamic dump
44 return is_dumping_static_archive() && HeapShared::can_write();
45 }
46
47 bool CDSConfig::is_dumping_full_module_graph() {
48 if (!_dumping_full_module_graph_disabled &&
49 is_dumping_heap() &&
50 MetaspaceShared::use_optimized_module_handling()) {
51 return true;
52 } else {
53 return false;
54 }
55 }
56
57 bool CDSConfig::is_loading_full_module_graph() {
58 if (ClassLoaderDataShared::is_full_module_graph_loaded()) {
59 return true;
60 }
61
62 if (!_loading_full_module_graph_disabled &&
63 UseSharedSpaces &&
64 ArchiveHeapLoader::can_use() &&
65 MetaspaceShared::use_optimized_module_handling()) {
66 // Classes used by the archived full module graph are loaded in JVMTI early phase.
67 assert(!(JvmtiExport::should_post_class_file_load_hook() && JvmtiExport::has_early_class_hook_env()),
68 "CDS should be disabled if early class hooks are enabled");
69 return true;
70 } else {
71 return false;
72 }
73 }
74
75 void CDSConfig::disable_dumping_full_module_graph(const char* reason) {
76 if (!_dumping_full_module_graph_disabled) {
77 _dumping_full_module_graph_disabled = true;
78 if (reason != nullptr) {
79 log_info(cds)("full module graph cannot be dumped: %s", reason);
80 }
81 }
82 }
83
84 void CDSConfig::disable_loading_full_module_graph(const char* reason) {
85 assert(!ClassLoaderDataShared::is_full_module_graph_loaded(), "you call this function too late!");
86 if (!_loading_full_module_graph_disabled) {
87 _loading_full_module_graph_disabled = true;
88 if (reason != nullptr) {
89 log_info(cds)("full module graph cannot be loaded: %s", reason);
90 }
91 }
92 }
93 #endif // INCLUDE_CDS_JAVA_HEAP
|
__label__pos
| 0.993187 |
Search:
Type: Posts; User: nafty
Search: Search took 0.19 seconds.
1. Replies
1
Views
1,166
How to detect pinch gesture on Mac touch pad?
Hi, I am trying to figure out if there is a way to detect the pinch-to-zoom gesture on a MacBook touchpad and how to do it. What I have in mind is something like a public void...
2. How to find indexes of ALL occurrences of object in ArrayList
Hi,
I am interested to find all the indexes where an element that I specify occurs in an ArrayList. Is there already a method for this? I see in the documentation that there are two similar...
3. Replies
4
Views
1,034
Collections vs. Objects
Hi,
I am new to the forum and new to collections. I am reading up on the basics of collections and trying to understand the difference between collections and objects. Firstly, are collections...
Results 1 to 3 of 5
|
__label__pos
| 0.769876 |
wpseek.com
A WordPress-centric search engine for devs and theme authors
get_media_states › WordPress Function
Since5.6.0
Deprecatedn/a
get_media_states ( $post )
Parameters:
• (WP_Post) $post The attachment to retrieve states for.
Required: Yes
Returns:
• (string[]) Array of media state labels keyed by their state.
Defined at:
Codex:
Retrieves an array of media states from an attachment.
Source
function get_media_states( $post ) {
static $header_images;
$media_states = array();
$stylesheet = get_option( 'stylesheet' );
if ( current_theme_supports( 'custom-header' ) ) {
$meta_header = get_post_meta( $post->ID, '_wp_attachment_is_custom_header', true );
if ( is_random_header_image() ) {
if ( ! isset( $header_images ) ) {
$header_images = wp_list_pluck( get_uploaded_header_images(), 'attachment_id' );
}
if ( $meta_header === $stylesheet && in_array( $post->ID, $header_images, true ) ) {
$media_states[] = __( 'Header Image' );
}
} else {
$header_image = get_header_image();
// Display "Header Image" if the image was ever used as a header image.
if ( ! empty( $meta_header ) && $meta_header === $stylesheet && wp_get_attachment_url( $post->ID ) !== $header_image ) {
$media_states[] = __( 'Header Image' );
}
// Display "Current Header Image" if the image is currently the header image.
if ( $header_image && wp_get_attachment_url( $post->ID ) === $header_image ) {
$media_states[] = __( 'Current Header Image' );
}
}
if ( get_theme_support( 'custom-header', 'video' ) && has_header_video() ) {
$mods = get_theme_mods();
if ( isset( $mods['header_video'] ) && $post->ID === $mods['header_video'] ) {
$media_states[] = __( 'Current Header Video' );
}
}
}
if ( current_theme_supports( 'custom-background' ) ) {
$meta_background = get_post_meta( $post->ID, '_wp_attachment_is_custom_background', true );
if ( ! empty( $meta_background ) && $meta_background === $stylesheet ) {
$media_states[] = __( 'Background Image' );
$background_image = get_background_image();
if ( $background_image && wp_get_attachment_url( $post->ID ) === $background_image ) {
$media_states[] = __( 'Current Background Image' );
}
}
}
if ( (int) get_option( 'site_icon' ) === $post->ID ) {
$media_states[] = __( 'Site Icon' );
}
if ( (int) get_theme_mod( 'custom_logo' ) === $post->ID ) {
$media_states[] = __( 'Logo' );
}
/**
* Filters the default media display states for items in the Media list table.
*
* @since 3.2.0
* @since 4.8.0 Added the `$post` parameter.
*
* @param string[] $media_states An array of media states. Default 'Header Image',
* 'Background Image', 'Site Icon', 'Logo'.
* @param WP_Post $post The current attachment object.
*/
return apply_filters( 'display_media_states', $media_states, $post );
}
|
__label__pos
| 0.997731 |
+1 vote
in Data Structures & Algorithms I by (88.2k points)
What is a time complexity for finding all the tandem repeats?
(a) Ɵ (n)
(b) Ɵ (n!)
(c) Ɵ (1)
(d) O (n log n + z)
Query is from Suffix tree topic in chapter Trie of Data Structures & Algorithms I
The question was posed to me at a job interview.
1 Answer
+1 vote
by (786k points)
selected by
Best answer
The correct option is (a) Ɵ (n)
Best explanation: Tandem Repeats are formed in DNA when the nucleotides pattern repeats more than once. To check if a substring is present in a string of a length of n, the time complexity for such operation is found to be O (n). The time complexity for finding all the tandem repeats in a string is O (n log n + z).
Related questions
Welcome to TalkJarvis QnA, a question-answer community website for the people by the people. On TalkJarvis QnA you can ask your doubts, curiosity, questions and whatever going in your mind either related to studies or others. Experts and people from different fields will answer.
Most popular tags
biology – class 12 biology – class 11 construction & building materials chemistry – class 12 electronic devices & circuits network theory data structures & algorithms ii cell biology computational fluid dynamics engineering physics i discrete mathematics chemistry – class 11 aerodynamics casting-forming-welding i engineering mathematics operating system casting-forming-welding ii engineering drawing mysql engineering geology digital circuits wireless mobile energy management electrical measurements digital communications cyber security analytical instrumentation embedded systems electric drives computer fundamentals basic civil engineering advanced machining iot design of electrical machines physics – class 12 applied chemistry dairy engineering basic chemical engineering cloud computing cytogenetics bioinformatics aircraft design aircraft maintenance software engineering drug biotechnology digital signal processing biochemistry data structures & algorithms i automotive engine design avionics engineering material & metallurgy energy engineering cognitive radio unix electrical machines biomedical instrumentation object oriented programming electromagnetic theory analog communications bioprocess engineering civil engineering drawing engineering metrology physics – class 11 mathematics – class 12 engineering chemistry i basic electrical engineering unit processes mongodb cryptograph & network security hadoop mathematics – class 11 engineering physics ii html control systems engineering mechanics antennas analog circuits computer network java sql server javascript concrete technology chemical process calculation artificial intelligence design of steel structures c++ database management computer architecture engineering chemistry ii corrosion engineering chemical technology dc machines automata theory digital image processing r programming matlab rdbms compiler aircraft performance aerospace materials & processes
...
|
__label__pos
| 0.939553 |
Browse Prior Art Database
Anchor for Multireference in Hyperlinks
IP.com Disclosure Number: IPCOM000240692D
Publication Date: 2015-Feb-18
Document File: 3 page(s) / 52K
Publishing Venue
The IP.com Prior Art Database
Abstract
A method to define and implement multiple links anchors for hyper-text documents to support the scenario where the same group of words in a document can match multiple concepts referenced in a repository of documents and resources.
This text was extracted from a PDF file.
This is the abbreviated version, containing approximately 52% of the total text.
Page 01 of 3
Anchor for Multireference in Hyperlinks
In a Content Management System, documents are enriched by inserting hyperlinks that can allow the user to navigate from the page that is actually being read towards referenced informative pages giving the reader a more complete understanding of the matter contained in the original page.
Example of content with hyperlinks in blue:
[...
To derive a more detailed model it's necessary to take into account of quantum mechanics prediction for the possible state of electrons and for statistical mechanics regarding the energy distribution of particles, like in the so called model of Sommerfeld that is:
...]
On the Html code of the page containing the content above hyperlinks is usually coded by two parts: the anchor that usually is the words of the set of words that reference should add details and the reference that is a an URL address where all details are stored.
Here follows an example html code of the content illustrated above: [...
<p> To derive a more detailed model it's necessary to take into account of<ahref ="/articleArchive/Quantum_Mechanics"title="Quantum mechanics">quantum mechanics</a> prediction of possible states of <ahref ="/articleArchive/Electrons"title="Electrons"class="mw-redirect">electrons </a> and for <ahref="/articleArchive/Statistical_mechanics"title ="Statistical Mechanics">Statistical mechanics</a> regarding the energy distribution of particles, like in the so called <ahref ="/articleArchive/Sommerfeld's model"title="Sommerfeld model">Model of Sommerfeld</a>. that is:</p>
<
dl>
...]
There might be cases where:
a) multiple reference have the same anchor
b) anchor of multiple references are formed by set of words that have
not null intersections each other.
On both cases the writer of the document is currently forced to abandon some of the hyperlinks or needs to try to re-elaborate his test. The method proposed here provides to the reader a menu with the entire set of possible choices, constituted by couples: exact anchor words , meaningful description.
1
Page 02 of 3
The user by clicking the desired choice is linked to related reference choosing among a different group of navigation routes. Back compatibility should be assured and thus the invention should assure that normal browser do not result in error. In this sense a change in html directives is needed to indicate this is a case for multiple links. The proposed suggestion is the introduction of a special keyword to signal a new html language tag
(...
|
__label__pos
| 0.861735 |
Skip to content
Related Articles
Related Articles
Strored Procedures classification based on Input and Output Parameters in SQL Server
• Last Updated : 21 Jan, 2021
Stored Procedure:
The stored procedure has the following key points as follows.
1. It is a collection of SQL statements such as if you want to write and read data from a database then you can use create a statement for write and select statement for reading the data from database and SQL command logic for the same, which is compiled and stored on the database.
2. A stored procedure is a group of T-SQL (Transact SQL) statements.
3. If you have a situation, where you can write the same query over and over again, you can save that specific query as a stored procedure and call it just by its name.
Classification of Stored Procedure
Create Stored Procedure without Parameter :
You can use the following stored procedure given below to create the stored procedure without a parameter.
create procedure sp_get_empno
as
begin
select * from emp where ename='WARD'
end
exec sp_get_empno
Create a Stored Procedure with Output Parameter :
You can use the following stored procedure given below to create the stored procedure with an output parameter.
declare @empId int
exec GetEmployeeID (@empId int out)
create procedure sp_get_empid(@name varchar(10) out)
as
begin
select id from emp where ename="Sam"
end
exec sp_get_empid @empID
Create a Stored Procedure with Input Parameter :
You can use the following stored procedure given below to create the stored procedure with an Input parameter.
USE Db1
GO
CREATE PROCEDURE dbo.GetEmployeeID(@Email varchar(30))
AS
SELECT * FROM employeeDetails WHERE email= @Email
GO
Create a Stored Procedure with both input and Output Parameter :
You can use the following stored procedure given below to create the stored procedure with both an input and output parameter.
create procedure sp_get_empname(@name varchar(10) out, @id int)
as
begin
select ename from emp where empno=@id
end
declare @en varchar(10)
exec sp_get_empname @en,7521
print @en
My Personal Notes arrow_drop_up
Recommended Articles
Page :
|
__label__pos
| 0.988371 |
Rust HDK (Holochain Development Kit): Basics of Developing Distributed Peer-to-Peer Holochain Apps
Rust HDK (Holochain Development Kit): Basics of Developing Distributed Peer-to-Peer Holochain Apps
By rhyzom | rhyzom | 18 Apr 2020
"Computers are language machines."
— Paul N. Edwards
So, Holochain, as some of you are perhaps well aware, is a development framework for peer-to-peer social apps (for, broadly speaking, large-scale sense-making, coordination and distributed, collective intelligence) — such that they run on distributed hash tables (DHTs, similar to BitTorrent), with each hApp (holochain app) instantiating and using its own (self-validating) DHT, according to the app-specific validation rules (as specified in its DNA file). So, Holochain uses DHTs as the public space and sourcechains (local hashchains, basically, in principle blockchains - but as associated with an agent/user and his private records) as the local records — holochain entries need to be explicitly marked public otherwise they're committed to an agent’s local chain. A public entry to the DHT on the other hand will be passed to other agents/peers via gossip, validated and collectively held together (as referenced in the DHT by its key) and any other agent can retrieve your public entries. Such arrangement allows that one records/stores only what is relevant to him/her in any given circumstance and doesn't need a massively replicated monolithic blockchain or universal network-wide consensus (instead of consensus, there are the app-specific validation rules which define the individual perspectives and behaviors of participants relative to their preferences, records and relationships, i.e. agent-centric).
3143414223-130dc4b010cab40d729a6aea6e043999a25dbadf3c1624e4b0048cdeb38ffa36.png
Holochain application architecture. A shared DHT as the public space with each individual agent storing his own source hashchain which interacts with the DHT via the Zomes in the applications DNA (which specifies the validation rules and application logic and every DNA has its own private, end-to-end encrypted network of peers who gossiping with one another). Holochain started out with a Kademlia type DHT, but what later changed to rrDHT (the working name for Holochain's specific DHT) which embeds Holochain's agent-centric assumptions deep into the design - the address space looks like a wheel, and (as with Kademlia) agents and data live in the same address space. A DHT is basically a key-value store that locates information and value by mapping it to a key. The node ID itself actually provides a direct map to value/information hashes and stores information on where to obtain that value, information file or resource. When searching for a value, the algorithm needs to be given the associated key and the traverses the peer-to-peer network in several steps, getting closer to the key at each following step until eventually hitting on a node which returns sought value.
Anyway, Holochain is meant to make app development easy and accessible, kind of like a simple and intuitive web development framework. And hApps are meant to be interoperable and composable similar to how UNIX pipes for example can make one program take another program's output as input (in a kind of dataflow style programming). The already mentioned Semtrex (Semantic Tree Regular Expression Matcher) is also a kind of extended Regex. Holochain and the broader concept of Ceptr (which is to be evolved and extended from Holochain as the fabric of a new crypto-semantic Internet) basically constitute a computational model and framework inspired by the principle of biomimicry — also known known as bio-inspired computing (or applying principles from biology and living systems in tackling computational problems, and specifically such to do with scalable distributed systems and social behavior).
Distributed hash tables store resource locations throughout the network. A major criterion for these protocols is locating the desired nodes quickly. In Kademlia type DHTs, a node's ID provides a direct map to file hashes and stores information on where to obtain the file or resource. When searching for some value, the algorithm needs to know the associated key and traverses the network in several steps with each step coming closer to the key until a node eventually returns the value or no further closer nodes are found.
Distributed hash tables are a much more mature decentralized technology than blockchain and is particularly resistant against things like denial-of-service attacks since even if a whole set of nodes is flooded, this will have limited effect on network availability, since the network will recover and re-constitute itself by knitting the network around these "holes", much like a rhizome, "ceaselessly established connections between semiotic chains, organizations of power, and circumstances relative to the arts, sciences, and social struggles"
Overall, DHTs are a very powerful technological basis for a wide range of possible networked media scenarios, but particularly such that elude capture and mitigate central points of failure in distributing themselves widely across time and space. Holochain provides a more general framework for building applications that run on distributed hash tables.
The initial Holochain prototype was written in Go, but later the whole thing had been re-written in Rust and the initial release and the first HDK will be in Rust as well — later on there will be SDKs on Javascript, Python and others, but Holochain is to use Rust and compile down to Wasm under the hood (which, as a highly secure and incredibly efficient systems language, designed as a kind of C/C++ for the networked world of tomorrow, seems to be an obvious choice for something like Holochain). The HDK is basically a customized/optimized Rust, making extensive use of macros (which can be used to design/implement domain-specific languages (DSLs) on the basis of Rust) to make hApp development as smooth as possible.
Bootstrap an hApp in a Single Command
Before diving in the HDK itself should perhaps mention the recently released scaffolding tool for hApps. Apps tend to have a common structure they share, of what's located where and under what file name or sub-directory, etc. — which is known as the general application scaffold. And there's hApp crate available now which spares you the creating of project (config, etc.) files and folders manually by instantiating the scaffold for a basic hApp. To test it, open terminal and install the nix package manager (which Holochain uses) with "curl https://nixos.org/nix/install | sh". Then enter the Holochain development environment with "nix-shell https://holochain.love" and create your app with "hn-happ-create basic-app". To then run it, go to the root directory (with "cd basic-app") and launch it with "yarn start".
Holochain Development Kit (HDK) in Rust
Holochain DNA needs to be written in something that compiles down to Wasm (WebAssembly) and an ideal candidate for that very purpose is Rust. The HDK is designed to allow the developer to focus on application logic as much as possible, without the bother of having to think about the underlying low-level implementation - and here, again, the Rust language and the compiler (which is particularly verbose) are built so that they relieve you from much of that low-level burden. Not least of all, learning Rust is actually something that would end up being mighty useful in the new world paradigm of peer-to-peer decentralization — a skill which is to be highly valued and sought after.
Anyhow, the Rust HDK does take care of some of the low-level details of Wasm execution, such as memory allocation, (de-)serializing data and shuffling data and functions in and out of Wasm memory with the help of the pre-defined Holochain-specific macros functionalities that Rust allows (using Rust macros is how you go about designing domain-specific languages in Rust). There's also an Atom package of Rust HDK snippets available that may come handy (for those using the Atom editor as an IDE and for highlighting/syntax/etc. anyway).
What is a (Rust) macro?
Macro, in Rust, refers to a family of features which include declarative macros (the ones in question currently), expressed with macro_rules! and 3 kinds of procedural ones, which we'll not get into right now. Fundamentally, macros are a way of writing code that writes other code (e.g., println!), thereby reducing the need for boilerplate code. This approach is also known as meta-programming — macros basically expand to produce more code than the code that's written manually. Also, macros are expanded before the compiler interprets the meaning of the code, so a macro can, for example, implement a trait on a given type.
A function can’t, because it gets called at run-time and a trait needs to be implemented at compile time. Another important difference between macros and functions is that you must define macros or bring them into scope before you call them in a file, as opposed to functions you can define anywhere and call anywhere. As already mentioned, macros in Rust can be used to implement various domain-specific languages (DSLs, such as contracts scripting languages, etc.) based on Rust.
Throughout the process of developing on Holochain using the HDK it will be helpful to check around and come back to the reference, but the starting point is the define_zome! macro, and the list of exposed functions that Holochain offers, namely the API. The underlying API functions and callbacks are binary and Wasm based in the Rust release and Containers have been introduced to the architecture stack of Holochain with Rust becoming the underlying programming paradigm of choice.
The define_zome! macro
Zomes (from rybosomes, the building blocks of the language of DNA; the analogy actually runs deeper than it may seem at first as Holochain does apply the concept of biomimicry and is at bottom an bio-inspired project) are the fundamental units of composability of an app's DNA — like modules providing some self-contained functionality or other that are callable via exposed API calls. Every zome uses the define_zome! macro to define the structure of that zome — what entries it contains, which functions it exposes and what to do on first starting (genesis or being called/executed/initialized for the first time). As seen in the code below, the define_zome! macro is defined by 4 components: entries, init, receive and functions:
• entries: an array of ValidatingEntryType as returned by using the entry macro (explained further below).
• init: init is a callback called by Holochain to every Zome within a DNA when a new agent is initializing an instance of the DNA for the first time, and should return Ok or an Err, depending on whether the agent can join the network or not.
• receive (optional): receive is a callback called by Holochain when another agent on a hApp has initiated a direct end-to-end/node-to-node message (initiated via the send function of the API, which is where you can read about the use of send and receive) — receive is optional to include, based on whether you use send anywhere in the code.
• functions: functions declares all the Zome's functions with their input/output signatures.
Here's the Rust code that defines the define_zome! macro:
macro_rules! define_zome {
(
entries : [
$( $entry_expr:expr ),*
]
init : || {
$init_expr:expr
}
validate_agent: |$agent_validation_param:ident : EntryValidationData::<AgentId>| {
$agent_validation_expr:expr
}
$(
receive : |$receive_from:ident, $receive_param:ident| {
$receive_expr:expr
}
)*
functions : [
$(
$zome_function_name:ident : {
inputs: | $( $input_param_name:ident : $input_param_type:ty ),* |,
outputs: | $( $output_param_name:ident : $output_param_type:ty ),* |,
handler: $handler_path:path
}
)*
]
traits : {
$(
$trait:ident [
$($trait_fn:ident),*
]
)*
}
) => { ... };
}
And here's an example of its usage in defining the simplest Zome possible (with no entries and no exposed functions):
#[macro_use]
extern crate hdk;
define_zome! {
entries: [
]
init: || {
Ok(())
}
validate_agent: |validation_data : EntryValidationData::<AgentId>| {
Ok(())
}
functions: [
]
traits: {
}
}
Zome definitions as the above are stored in the lib.rs of the Zome (in its corresponding sub-directory in the DNA folder).
The other HDK-specific macros are entry, from, link and to:
• entry! macro - a helper for creating ValidatingEntryType definitions for use within the define_zome macro - has 7 component parts:
• name: descriptive name of the entry type, such as "post", or "user".
• description: primarily for human readers of the code, just describing the entry type.
• sharing: defines what distribution over the DHT, or not, occurs with entries of this type, possible values are defined in the Sharing enum.
• native_type: references a given Rust struct, which provides a clear schema for entries of this type.
• validation_package: a special identifier, which declares which data is required from peers when attempting to validate entries of this type — possible values are found within ValidationPackageDefinition. It is a function defining what data should be passed to the validation function which is a function that performs custom validation for the entry. An argument can be an entry, but also it is possible to pass chain headers, chain entries or the entire local chain.
• validation: is a callback function which will be called any time that a (DHT) node processes or stores this entry, triggered through actions such as commit_entryupdate_entryremove_entry — it always expects two arguments, the first of which is the entry attempting to be validated, the second is the validation context, which offers a variety of meta-data useful for validation (see ValidationData for more details).
• links: a vector of link definitions represented by ValidatingLinkDefinition, can be defined with the link! macro or, more concise, with either the to! or from! macro, to define an association pointing from this entry type to another, or one that points back from the other entry type to this one (see link!to! and from! for more details).
• from! macro — a helper for creating ValidatingEntryType definitions for use within the entry! macro — a convenience wrapper around link! that has all the same properties except for the direction which gets set to LinkDirection::From.
• link! macro - a helper for creating ValidatingEntryType definitions for use within the entry! macro - has 5 component parts:
• direction: direction defines if the entry type (in which the link is defined) points to another entry, or if it is referenced from another entry — must be of type LinkDirection, so either hdk::LinkDirection::To or hdk::LinkDirection::From.
• other_type: other_type is the entry type this link connects to — if direction is to this would be the link target, if direction is from this defines the link's base type.
• link_type: link_type is the name of this association and thus the handle by which it can be retrieved if given to get_links() in conjunction with the base address.
• validation_package: similar to entries, links have to be validated — validation_package is a special identifier, which declares which data is required from peers when attempting to validate entries of this type (the possible values are found within ValidationPackageDefinition).
• validation: validation is a callback function which will be called any time that a (DHT) node processes or stores a link of this kind, triggered through the link actions link_entries and remove_link — it always expects three arguments, the first being the base and the second the target of the link, the third is the validation context, which offers a variety of meta-data useful for validation (see ValidationData for more details).
• to! macro - a helper for creating ValidatingEntryType definitions for use within the entry! macro. It is a convenience wrapper around link! that has all the same properties except for the direction which gets set to LinkDirection::To.
The `Serialize` and `Deserialize` derived traits allow the structs to be converted to and from JSON, which is how entries are managed internally in Holochain. JSON was chosen as the interchange format because it is universal and almost all languages have serializers and parsers. Rust’s is called serde. The three serde (Serialization framework for Rust) related dependencies all relate to the need to serialize to and from JSON within Zomes. The process of translating/converting one stream/format/data/convention to and from some other is most of what Holochain actually does in practice — and how "current-sees" or flows are defined (within the constraints of their validation rules which define them as such).
Links in holochain work, in principle, similarly to Linked Data (in how Solid makes use of RDF, etc.) - it is likewise a kind of ontology engineering, allowing for the traversing across different domains and translating between them, revealing/creating otherwise hidden or surprising connections between things. Web ontologies have come to be of much significance in the digital humanities, one such example being the Seshat Global History databank (in .ttl / Turtle), extensively used in cliodynamics research to test theories and models and discover correlations, inter-dependencies and key factors driving socio-economic and historical processes. Holochain aims to both reveal and create (making us actively aware of) social flows and allow for composable arrangements between them as means for organizational coherence. (Imagine breathing, animated Chinese or Mayan ideograms.)
5079a1a2a93b27f595989a716e6fc0e57bf1b5afed6ab39514a4599de219b21b.jpeg
Mayan ideograms (hieroglyphs). Ideographic scripts/languages, unlike alphabetic ones, directly express concepts and ideas and compose meaning and expressions by combining them in arrangements. This has the effect of immediately revealing etymology, intention, scope and nuance, context and circumstance and tends to encode/compress much more information than the alphabetic phonemes, which simply stand for glottal sounds and is rather (to use the words of Marshall McLuhan) "an aggressive and militant absorber and transformer of culture". Holochain's composability follows a somewhat similar underlying principle as that of ideographic languages like Chinese and Mayan scripts. hApp creation is a kind of concept creation (which, according to Deleuze, is the work/function of philosophy) - as component glyphs of the vocabulary, but dynamic and animated, machinic and distributed (as DHTs). The formed connections and relationships (translations/transformations) between hApps, records, agents and entries, constituting a massive growing DAG of complex webs, mapping planes of consistency and immanence, virtuality and actuality, potentiality and possibility.
Self-writing historical records on the surface of a BwO ("body-without-organs") and the implied possibility of universal history therein (what schizoanalysis aims for) — in a way, Holochain is practical schizoanalysis as applied in its proper scales and domains (and as a critique/opposite of psychoanalysis, its privately bourgeois character of thinly veiled hypocrisy and institutionalized bullshit enacted as seriousness and deep esoteric knowledge). Perhaps another word for "schizoanalysis" - or something close enough to it to be almost exactly the same (even in the words of Latour himself, who said he would have termed it "rhizome-actant theory") - Actor Network Theory (ANT). “We neither think nor reason,” Bruno Latour writes, “Rather, we work on fragile materials—texts, inscriptions, traces, or paints—with other people.”
Holochain can also serve as a research instrumentarium in helping one become his own anthropologist (in the sense of McLuhan media theory as radical anthropology) and/or analyst (of the schizo type, not the ego preoccupied and fixated neurotic of Freud and Lacan) - all kinds of conceptual tools, methodologies and heuristics can be implemented and combined using Holochain (could become an invaluable tool for the digital humanities), and various machinic assemblages and bricolages put together ad hoc and on the fly as circumstances require, operational/organizational regimes switched between one and the other in response to changes and necessity, etc. - in a word, precisely what an approach dealing with non-linear complex dynamics in the real world requires.
As a framework for currencies design (in the sense of "current-sees", or social flows of things with money-like qualities, but not necessarily money per se), Holochain is meant to enable the making visible of such flows and organizing them in articulating vectors of distribution towards clearly defined and desired outcomes. It shares something of the view of social ecology (of Murray Bookchin and as taken up by Abdullah Ocalan and his democratic confederalism, as practiced in the Rojava region in Northern Syria today) — which, interestingly enough, is also quite fully captured and contained in the concept of what is in Greek referred to as "miasma" (meaning, among other things, stain, pollution, defilement, taint of guilt).
>>> ...bit of a U-turn drifting away into other things Holochain, this above and the section just below....
Software as Art Rather Than Engineering
Recently came across Warren Sack's book, "The Software Arts" which makes an actually important (or important enough to be explicitly made, I think) point about software development and it being more like art — as "software engineering" isn't quite exactly engineering for the most part (and neither is financial one for that matter), but the term itself has done some harm as it does imply an engineering approach to problems and things where much more nuanced and inter-disciplinary methods and mindsets ought to apply. An engineering problem is a complicated, expertise problem, as per the Cynefin Framework, while most real world problems tend to be of the complex non-linear variety, involving unknown number of unknown unknowns and myriads of interwoven, tangled variables across many dimensions and domains - where gentle probing and small scale experimentation necessitate, along with ad hoc heuristics and domain-specific designs (or Feyerabend's methodological pluralism and epistemological anarchism of the single universal principle of "Anything goes").
Increasingly, in academia, industry and government, ideas and concepts are exchanged as software and code rather than as printed prose documents. Software now constitutes a new form of logic, rhetoric and grammar, a new means of thinking, arguing and interpreting. Although, if we take Deleuze's distinction between the domains of science, art and philosophy (and what each of them deals with), software ought to more closely overlaps with philosophy (as the practice of inventing concepts) than with art (as producing affects). Although, if we consider performance art and the Artaudian theater of cruelty or art as embedded in and indistinguishable from everyday reality (rather than its own stage, domain, gallery or sphere), Bitcoin has without a doubt been the greatest piece of such demonstrative performance art in history (as I've always claimed) — in its pedagogic and educational value as well as sociopathic mockery and almost unbelievable spectacle of human stupidity, quasi-ideological nonsense and boiling of lower instincts and passions.
And without a doubt computing does also have strong aesthetic aspects and dimensions (except for Microsoft, of course, but Apple's innovations in commodity fetishism don't really count as anything of any actual value either I think) — in that regard, I find Urbit to be particularly aesthetic in its every aspect, from the minimally concise code base to the tabula rasa overlay of existing systems to its grounding of a calm technology sense and the kind of mindset that conditions (or is conditioned by). Urbit is more in the category of things that go about dealing with complexity by first grounding a Schelling fence of immutable simplicity and first principles (like Bitcoin in a way) - making sure that whatever can be simple and has no need to be complicated or muddled does not end up being so. Another example of such philosophy of simplicity is the constructed pidgin-like philosophical language Toki Pona
Most mainstream crypto-networks right now tend to focus on so-called "smart contracts" and financial applications — DeFi, open finance and the like. Basically enabling one to write business logic in code that executes deterministically on a public ledger and in a peer-to-peer fashion. All this is mildly interesting and mostly useless or even perhaps meaningless compared to what is (technologically and otherwise) possible and the kinds of things that might come to be that we can't currently even quite imagine yet. In that sense, Ethereum does lack something of a character or flavor, purpose and clearly defined goals, vision and consistency — being "general-purpose" and "value agnostic" doesn't really get one too far when one is not really sure what they want to accomplish or why they're even doing what they are. (And Tezos, in that same department and of open finance / fintech crypto-networks, seems to instead be very purpose-driven in its innovative approach and seeming clarity of what end goals it pursues.)
A whole lot more can be mentioned, but in any case Holochain also stands out as a great example of how "software is art" — as it strives to organically develop and evolve rich expressive and grammatic capacities of what it could articulate possible and the kinds of vocabularies, ontologies and terms it would have at its disposal to raise and state problems as such (as valid problems in the terms which raise them as such and in revealing in their statement the range of possible solutions) — ontology, or the language of what could be said and raised as such, is what conditions the epistemology of what it could possibly know within its structural constraints. (Perhaps also why whenever one switches from one language to another he tends to, in a certain neurological and psychological senses, switch between two distinct personalities of himself articulated in those languages.)
Art's role in facilitating sense-making and shocking or waking us into some other phenomenology of experience or being, sensing the surrounding world or being more acutely aware of things normally lying dormant and hidden in the background of our attention, etc. — all this is more easily achieved by making use of networked media and technologies in actually creating the conditions of what we seek to call into being or make possible, virtually or actually. Art should be made with a purpose and for use, but its adoption and common use and/or capture, appropriation and functional re-purpose ("deterritorialization") can be things rather opaque, double edged and operating simultaneously in a number of levels for the benefits of different things (e.g., honeypots). "The Medium is the message", or: the content of the TV news broadcast is as important as the graffiti inscribed on the atom bomb.
Thus, as the means for creating art get more powerful and dangerous, so should art become so as per the nature of its employed technological media — otherwise it ceases to be art (as art can only be such that it embodies the spirit of its times/Zeitgeist, an expression/manifestation of the era, such that it provides it with broader historical and social context and gives it its spiritual and intellectual taste and flavor). Therefore, art today may cross all boundaries necessary for it to have influence and affect, be those even legal or moral, etc. Sense-making being another function of art, the deliberate and programmed introduction/execution of unpredictability, insecurity and volatility does, as such, provide new information (information defined as difference from the usual and routine, the inertial drift and repetition, entropy and sudden abrupt change) and reveal things previously unknown. Also, counterinduction does constitute a legitimate approach to knowing something.
So, in a word, Holochain is also a framework for making art. The various possible expressions and embodiments of exactly what kinds of art is up to whatever the intended purposes and sought effects have been in the putting the technical artifact together.
Conductors: Interfaces Between the Transport Layer and the DNA Instances
Architecturally, as already mentioned, holochain app DNAs are meant to be small composable units that provide bits of distributed data integrity functionality (like simple/basic Unix shell programs that are built to work together). Thus, most holochain-based applications will really constitute assemblages of various different “bridged” DNA instances. For this to work a distinct layer that organizes the data flow (i.e., zome function call requests and responses) is necessary, one that interfaces between the transport layer (i.e., HTTP, Web sockets, Unix sockets, etc.) and the DNA instances. This layer is called the Conductor and there's a conductor_api library for building Conductor implementations. They (conductors) play a number of important roles:
• Installing, un-installing, configuring, starting and stopping DNA instances.
• Exposing APIs to securely make function calls to the Zome functions of DNA instances.
• Accepting information concerning the cryptographic keys and agent info to be used for identity and signing.
• Establishing “bridging” between DNA instances.
• Serving files for web-based user interfaces that connect to these DNA instances over the interfaces.
Those are the basic functions of a Conductor, but in addition to that, a Conductor also allows for the configuration of the networking module for holochain, enables logging, and if you choose to, exposes APIs at a special ‘admin’ level that allows for the dynamic configuration of the Conductor while it runs. By default, configuration of the Conductor is done via a static configuration file, written in TOML.
In order to run a DNA, a conductor needs to be configured to:
• Know about that DNA (i.e., its hash, DNA file location, how it should be referred to).
• Have an agent configuration that wraps the cryptographic keys and identity of the agent running the DNA.
• Incorporate the two in an instance that also specifies what storage back-end to use.
This creates a running DNA instance, but in order to use it there needs to also be some user interface and a connection between it and the DNA. So, the holochain conductor implements interfaces that also need to be set in the conductor config and each such interface configuration picks the instances made available through that specific interface.
Holoscape: End-User Deployment of a Conductor With Admin UI and a Run-time for hApp UIs
Holoscape sets up and maintains your Conductor config so that you don't even have to know what that even is, providing graphical user interface with access to all configuration dialogs and with simple means to install hApps via hApp bundles, as well as open/close hApp UIs via the tray icon (although the DNA/DHT instances keep running in the conductor even when an hApp UI is closed).
e96082f25e47cc39ca4b37a8503f8d0c00e55085c0ae16f0ace651a50535058f.png
hApp developers can much easier deploy their hApps by bundling them with everything related/relevant to the application and sharing those through Holoscape (similar to how an app store works). HoloSqape was the first such MVP hApp container to be released (using Qt and now non-maintained) with Holochain's Rust re-write which came with an UI that created inputs and buttons for each zome function a DNA exposes.
Other tools and useful resources
There's a handful of available useful helpers and tooling around Holochain, including a generic zome explorer interface for calling holochain dna zome functions, a development commons (Holonix) and others. Socket Wrench is also a useful GUI for talking to a WebSocket server that can be used to talk to a running conductor or one of its instances.
Zome Explorer for Calling/Examining Running Zomes in a Conductor
4df1151504fdca35f060475100662adf0c526b410f3f11b4ea1f66831393db7c.png
A GUI tool for examining and calling running zomes in a Holochain conductor. To install, clone the Github repo with git clone https://github.com/Hylozoic/zome-explorer.git and then run:
$ cd zome-explorer
$ yarn install
Basically a must among tooling and developer tools/components — seeing how things actually work in practice under the hood and getting sense of the p2p dynamics of how apps run and the underlying architecture/structure you'll write the application logic in.
Sim2h: Simple “switch-board” Networking
Sim2h is a centralized test networking alternative which is no longer used much. It was a secure centralized "switchboard" implementation of lib3h and a multiplexer for nodes using lib3h protocol to connect through a centralized security and validation service.
Holonix: Developer Commons and Environment Based on NixOS
Holonix was designed for facilitating developer productivity in an extensible and open source manner and focus on evolving conventions around a set of basic workflows — in this case, the building and testing of zomes and UIs, the documenting of code in the process and the release of artifacts. Holochain and the Holo initiative specifically work to build a rich ecosystem of many small micro-service style apps and the benefits of leveraging well tested sets of common use scripts and conventions tends to usually outweigh the reinventing of the wheel each time.
Workflows are achieved through a combination of automated management of dependencies and tools (on $PATH), the setting environment variables inside a shell session, simple bash scripts and scaffolding tools (such as hn-happ-create, mentioned in the beginning), virtual machines for continuous integration and extended platform support, conventions and project-specific configurations and the leveraging of the NixOS toolkit and package manager.
Holonix can be used in three basic ways that allow for increasing levels of sophistication and control:
• A project-agnostic one https://holochain.love 1-liner.
• A project-specific one with the default.nix configuration, and
• as a native NixOS overlay.
Write a simple hApp
For sharing data publicly you need to set the entry in the definition to 'public' — for that, go to your zomes/zome_name/code/src/lib.rs file and change the entry sharing from Sharing::Private to Sharing::Public:
fn person_entry_def() -> ValidatingEntryType {
entry!(
name: "person",
description: "Person to say hello to",
- sharing: Sharing::Private,
+ sharing: Sharing::Public,
validation_package: || {
hdk::ValidationPackageDefinition::Entry
},
validation: | _validation_data: hdk::EntryValidationData<Person>| {
Ok(())
}
)
}
....to be continued soon..
also see: https://holochain-community-resources.github.io/design-workshop/#0 - how to design holochain app
rhyzom
rhyzom
Verum ipsum factum. Chaotic neutral.
rhyzom
rhyzom
Ad hoc heuristics for approaching complex systems and the "unknown unknowns". Techne & episteme. Verum ipsum factum. In the words of Archimedes: "Give me a lever and a place to rest it... or I shall kill a hostage every hour." Rants, share-worthy pieces and occasional insights and revelations.
Send a $0.01 microtip in crypto to the author, and earn yourself as you read!
20% to author / 80% to me.
We pay the tips from our rewards pool.
|
__label__pos
| 0.628517 |
Parsing a two-dimensional language.
Many programming languages are essentially one dimensional. The parser treats them simply as a linear sequence of tokens. A program could all be written on a single line, or with each token on a separate line and the parser or compiler wouldn’t notice the difference. This set of languages includes Algol, Pascal, C, Rust and many others.
Some languages are 2-dimensional in a bad way. FORTRAN is probably the best example, though BASIC is similar. These (at least in their early forms) had strict requirements as to what can go on one line and what needs to go on a separate line.
A few languages are exploring the middle ground. Go will treat Newlines like semi-colons in certain cases which can result in a 2-dimensional feel, but brings with it some rather ad-hoc rules. Python probably makes the best attempt at 2-dimensional parsing of the languages that I have looked at. It allows newlines to terminate statements and also uses indents to indicate the grouping of some language elements, particularly statement groups.
While I find a lot to like in Python, it seems imperfect. I particularly dislike using a backslash to indicate line continuation. You can avoid this in Python by putting brackets around things as a newline inside brackets is ignored. But this feels like a weakness to me.
As I wrote in a recent article for lwn.net:
The recognition of a line-break as being distinct from other kinds of white space seems to be a clear recognition that the two dimensional appearance of the code has relevance for parsing it. It is therefore a little surprising that we don’t see the line indent playing a bigger role in interpretation of code.
This note is the first part of a report on my attempt to translate my intuition about parsing the two dimensional layout into some clear rules and concrete code. This note deals with indents. A subsequent note will look at non-indenting line breaks.
Indenting means continuation, newline means completion.
The two elements that give a section of code a two dimensional appearance are line breaks and indents. Without the line break there wouldn’t be any extra dimension at all. Without indents the code would just look like a block of text and we would be in much the same situation as FORTRAN and BASIC.
Each of these has a fairly well understood meaning. A line break often marks the end of something. This isn’t always true, and exactly what the “something” is might be open to interpretation, but this meaning is fairly well understood and line breaks rarely mean anything else.
An indent means some sort of continuation. The line that is indented with respect to a previous line is in some sense part of that previous line.
To help visualise this, consider:
A B C
D E
F
G H
Here “D E” and “F” are clearly part of the thing which starts “A B C”. “G H” may or may not be, much as “F” may or may not be part of “D E”. However if “D E” or even “B C” started something, then it definitely finished by “F”. “G” might be part of something that started a “A”, but if some subordinate thing started at “B” or later, it does not continue into “G”.
As a first step to formalising this we need to be able to encode this two dimensional structure into the stream of tokens which the parser can then process.
Generating a “NEWLINE” token at the end of each line, and maybe a “SPACE” token for each space at the start of a line could capture it but not in a very helpful way. It is not really the presence of an indent that is important but rather the change in indent. So between “C” and “D” we need to know that the indent level increased, while between “F” and “G” it decreased.
Python uses the terms “INDENT” and “DEDENT”. The first is technically inaccurate as every line is indented, not just the first. The second is a neologism presumably derived by analogy with “increase” and “decrease” or similar. Other options might be “UNDENT” or “OUTDENT”. I’m not sure I really like any of these. However “in/out” seems the best fit for what is happening so I’ll just call the tokens which report indent changes “IN” and “OUT”.
Using these two tokens, and ignoring the line structure for now, the above structure can be tokenized as:
A B C IN D E F OUT G H
This is very simple as there is only one indented block. A more complex example is:
A B C
D E
F G
H
I
This would be tokenized as:
A B C IN D E IN F G OUT OUT IN H OUT I
Note the sequence “OUT OUT IN” – we close two indented section and open another one all at one line break. This is because “H” has a lesser indent than “D”, but a greater indent than “A”.
This tokenization captures the structure very effectively and is what I will be using. Unsurprisingly, these are exactly the tokens that can be generated by the scanner I previously described though the token names have been changed.
What to do with indents?
Now that we have these IN and OUT tokens we need to understand what to do with them. Their significant value is that they are very strong syntactic markers. IN and OUT are strongly paired: it is very obvious which OUT matches which IN. This contrasts with bracketing markers like “{ }” or BEGIN and END or DO and OD. The latter can be accidentally deleted or forgotten. If OUT is forgotten, that omission will be obvious on every line.
I’ve recently be writing C code using the “text” mode of my editor (emacs) rather than the C mode. This is because I’ve been experimenting with literate programming and writing the code inside `markdown` markup.
I have really noticed that lack of help with auto-indenting. Each line is auto-indented to the same level as the previous line, which is certainly useful. But typing `}` doesn’t automatically drop back one level of indent. So sometimes I get it wrong.
When I do get it wrong, the compiler complains (as it should) but it is usually a cryptic complaint that is way too late. I would much rather it know there is a problem as soon as the indenting looks wrong. So error detection will be the first focus for exploring the use of indents.
To discuss how this works you really need a working knowledge of grammars and parsing. If you don’t have that yet, let me suggest me earlier note of LR grammars. If you don’t have time for that now, then press on anyway, it shouldn’t be too hard.
Unlike other tokens used in an LR grammar, IN and OUT cannot simply appear in the grammar where ever they are expected. This is because there are really too many places that an IN can appear. An OUT must be at the end of something, but that matching IN can often be anywhere in the middle. So the parser will need to have direct knowledge of IN and OUT tokens. It will not “SHIFT” them onto the stack as it does with other tokens. It has to handle them directly.
As an OUT enforces the end of something the natural thing to do when an OUT token is seen in the look-ahead is to perform REDUCE actions until the OUT is balanced by some IN that was previously seen. This is clearly a very imprecise rule. We need to explore some examples before we can make the rule suitably precise.
We can start looking at examples supposing a grammar containing:
Statementlist -> Statementlist Statement
|
Statement -> if Condition : Statementlist
| print String
A program fragment like:
if a == b :
print "Hello"
print "World"
print "End"
would then result in the following LR stack just as the OUT token appears in the look ahead:
if Condition : Statementlist print String [OUT]
The IN appeared just before the Statementlist and the only possible reduction is to reduce”Statement -> print String” so we would do that which results in
if Condition : Statementlist Statement [OUT]
Again we can reduce and still stay after the indent so now we reduce “Statementlist -> Statementlist Statement” and get to:
if Condition : Statementlist [OUT]
Now the symbol on the top of the stack is where the indent started, so we need to stop reducing. It might seem appropriate to reduce this fully to a “Statement” but we cannot do that based on just the indent. Consider a different language with a fragment like:
if ( a == b ) {
print "Hello";
print "World";
}
In this case it is clear that the OUT itself is not enough to close the whole statement. Resolving this will have to wait until we explore how line-structure works.
So the approach for handling IN and OUT seems to be that when we see an IN, we mark the next symbol SHIFTed as being indented. Then when we see OUT we stop SHIFTing and REDUCE until the symbol on the stop of the stack is marked as indented. We can then clear that marking, discard the OUT, and continue.
This is close to a working solution but there are a few complications that need to be resolved first. One relates directly to the fact that “Statementlist” is recursive.
Statementlist -> Statementlist Statement
This means that reducing until we just have “Statementlist” on the top of the stack doesn’t stop more things being added to that Statementlist. The idea was that the OUT should complete close the Statementlist but because of its recursive nature that isn’t really possible.
This is easily fixed by introducing a second “dummy” nonterminal.
Statementlist -> _Statementlist
_Statementlist -> _Statementlist Statement
|
This set of productions will parse exactly the same language but will introduce an extra state. If we see an OUT token we can reduce back to a “_Statementlist” as we did before, and then go one more step and reduce to the new “Statementlist”. Once there we really have closed the list. Another statement cannot extend it like it could in the simpler grammar.
These extra “dummy” non terminals could easily be added by the parser generator itself. However they solve one problem by providing another. Previously we could simply REDUCE until the top of stack carries an IN, and the cancel the IN. Now we might need to REDUCE one more step – the “Statement -> _Statement” production above. How can we know when to stop?
The answer to this requires that we store one more bit (literally) of information in the state stack. We currently have a count of the number of indents which appear “within” (the full expansion of) the symbol in the stack entry. By that we mean the number of terminals which were reduced into this symbol and were immediately preceded by an IN. To that we must add a flag to record whether the first terminal was preceded by an IN. i.e. is the whole symbol indented or just part of it.
Now the rule will be that if we have an OUT token in the lookahead buffer and the top-of-stack token contains an IN that was not at the start then we can simply cancel the IN and discard the OUT. Further, if the top-of-stack contains only one IN and it was at the start then we need to look at the production that we can reduce. If that production contains more than one symbol in its body then again we can cancel the IN and discard the OUT. In this case, that IN would be not at the start of the symbol we would reduce to, so it is somewhat similar to the first case.
Another way to look at this is to say that when we see an OUT token, we reduce until the next reduction would contain an internal (i.e. not at the start) IN. Once we find this internal IN we cancel it and discard the OUT.
Indenting affect error handling in two ways. Firstly we need to know what happens if an OUT implies a reduction is needed, but the current state does not allow a reduction. Secondly we need to know how to handle IN and OUT tokens if they are found while discarding input tokens during normal error recovery.
In the first case, the fact that we want to reduce suggests that we must have part of the right hand side of a product but not all of it. It would be nice to keep what we have, so to complete it we need to synthesize the extra tokens needed to make a complete production. If there is no reducible production at this state then there must be symbols that can be shifted. So we can synthesise one of these – the one that gets us as close to the end of a production as possible. This may result in an ‘unknown variable’ or similar which would need to be carefully suppressed, but would allow any valid units with the production so far to be properly analysed.
For the second case we can simply count the INs and matching OUTs until we find a SHIFTable symbol or find more OUTs than INs. If we find a SHIFtable symbol, we set the IN count for that symbol to the net number of INs. If we find an extra OUT it means that we must have come to the end of whatever high level non-terminal was in error. We we just leave the ERROR token on the stack without shifting anything else and move on to normal handling for an OUT token. This will either reduce whatever is on the stack, or will synthesize some token to allow parsing to continue.
It should be noted here that I haven’t experimented a lot with this error handling process. It seems to make sense, but often things which seem to make sense actually don’t. So this might need to be revised.
This then is the complete description for how to handle IN and OUT tokens. In summary:
1. Each frame in the LR state stack must contain a count of the number of IN tokens it contains, and a flag to record if one of these is at the start.
2. When we see an IN token we record the fact and discard it. When we SHIFT in a new terminal we check if we just saw an IN. If so the new entry is the stack records that one IN is present, and that it is at the start.
3. When we reduce a series of symbols to a single non-terminal we add up the number of included IN tokens in each and use that as the count for the new token. The “one at the start” flag from the first symbol is inherited by the new symbol.
4. When we see an OUT token we check if the top-of-stack contain a “not at the start” IN token, or if it contains an “at the start” IN but the next reduction would make it “not at the start”. If either of these are true we decrement the IN counter and discard the OUT. Otherwise we REDUCE a production if we can, and synthesize some suitable symbol to SHIFT if we cannot.
5. When we discard stack states during error handling, we count the number of indents and add them to the “ERROR” state that we ultimate SHIFT.
6. When we discard look-ahead tokens during error handling we keep count of and IN and OUT tokens. If we see an OUT token when the count is zero, we assume a sane state has been found and return to where step 4 above was handled. Otherwise the IN count of the token which ultimately resolves the error is set to the balance of INs and OUTs.
The net result of this is that an OUT always closes anything that was started at or after the matching IN, but nothing that was started before the matching IN.
This adjunct to LR parsing can be used in two different but related ways. Firstly as already noted it can improve error reporting. If a ‘closing’ token like “}” is missing then that will be noticed immediately. The syntactic unit that it is meant to close (e.g. Statementlist) will already have been reduced by an OUT and if the “}” doesn’t follow a regular LR parsing error will occur.
Secondly, and more interestingly for language design, an ambiguous grammar can be cleanly resolved by treating indentation as meaningful.
The classic “dangling else” case can be easily resolved by the indentation of the ‘else’.
if (COND1)
if (COND2)
StatementA;
else
StatementB;
is no longer ambiguous. The “else” clearly relates to the first “if”, not the second.
Ocean will make use of this to have a syntax for “blocks” of statements which does not require a closing token. They will be closed by a reduction in indenting. As explicit closing can sometimes be preferred, Ocean will also allow C-style blocks. Possibly that should be “go-style” blocks as a block must not be a single statement.
The syntax I’m experimenting with at the moment includes:
Block -> : Statementlist
| { Statementlist }
Statement -> if Expression Block
| if Expression Block ElsePart
| ...
ElsePart -> else Block
| else if Expression Block
| else if Expression Block ElsePart
This allows structured statements that look like Python or like Go, and will use indentation to resolve ambiguities in the Python style, and report errors in the Go style.
My intention is that several other structures will allow either “{}” or “:..” formats. “struct” type declarations is an obvious one. Others might occur as design proceeds. However before we can proceed with those details we need to finish the two-dimensional parsing which is only half done. This note dealt with indents, the next note deals with end-of-line marker.
Meanwhile code that manages indents as described here can be found in `git://neil.brown.name/ocean` or this version of the parser generator.
Posted in Language Design | Leave a comment
Wiggle 1.0
About 11 years ago I started writing “wiggle”. I have finally released version 1.0.
Wiggle is a tool for applying patches with conflicts. I do quite a bit of applying patches to a release different to the one they were created for. This often works, and often fails completely so that the task must be done completely by hand.
But sometimes – and often enough to be worth automating – the ‘patch’ program cannot apply the patch successfully, but the reason is due to small differences that can automatically be detected and ignored. This is where “wiggle” comes in. It looks at the patch word-by-word, and wiggles that patch in if at all possible.
I got wiggle to the point where this basic functionality worked a long time ago. But I found it less that satisfactory. Often “patch” would fail and “wiggle” would succeed and I would want to know why. And “wiggle” didn’t really tell me why.
This lead me on the path of writing “browse” mode for wiggle. This allows me to look at the merge and see the different bits highlighted so I can see what confused “patch” and decide if it was reasonable for wiggle to silently fix it.
I then found that I wanted to be able to “fix” things up while in browse mode. Some little conflicts that wiggle cannot fix automatically still have simple fixes that I could determine based on my understanding of the code. Figuring out how to do that was not easy. I knew in general terms what I wanted to achieve, but had no real idea of the concrete steps.
So much of the last few year, when I have had the opportunity, has seen me improving various aspects of the browser, making it easy to move around and handling various corner cases and getting enough ground work in place that I could usefully experiment with editing. Only recently have I taught wiggle some very basic commands for editing. I don’t really know if they are enough, but they will do for now.
There are basically 3 things you can do.
1. You can mark a conflict or change and “unchanged”. This effectively ignores part of the patch and leaves the original as it is.
2. You can mark a conflict or ‘unmatched’ as ‘changed’. This effectively discards the original and keeps what was in the patch, even though it might not have lined up properly.
3. After the above has proven to be insufficient, you can open the merge result in an editor and fix the rest up by hand.
Obviously the last possibility has always been an option, though not directly from wiggle. This is how I most often work with failed patches. I apply “wiggle” then look at the results in an editor. Allowing the editor to be invoked directly from wiggle should streamline the process a little. Allowing some simple changes before hand should make it even better. Only time will tell.
So wiggle 1.0 is out there, in git://neil.brown.name/wiggle/ or http://neil.brown.name/wiggle/. If you want to know more, you can see the talk I recently have at LCA2013.
Posted in Uncategorized | 2 Comments
Parsing LR grammars
It is time for another diversion, but it is leading towards the language design – honest.
LR grammars are a tool for specifying the grammar for a language, and it is fairly easy to automatically generate a parsing tool from a grammar. So they have often been used for this purpose.
There seems to be some suggestion that LR is no longer to tool of choice (see wikipedia, apparently because it is hard to do good error reporting. The gcc compilers converted from an LR grammar to a recursive descent LL grammar, apparently for this reason.
However I like LR grammars and I don’t see the problem. So I plan to start out with an LR grammar approach. Either it will work well, or I will start the see the problem, and either out come in positive in my view. So I cannot lose.
There are plenty of tools available for converting an LR grammar into code, of which GNU “bison” is probably best know, but I’m going to write my own. Partly this is because it will help me learn, and partly because it will add to the collection of code that I have recent experience with so that when Ocean starts to take shape I will have lots of example code to try translating to it. But mostly because it is fun.
So this post is about LR grammars and building a tool to parse them. You’ve probably read all this before elsewhere, so I suggest you stop reading now and go do something useful like play sudoko. Come back in a few weeks when I will have moved on.
However, it is also possible that you have tried to read about this and, like me, failed to find anything really accessible. There are academic papers that are full of dense mathematics which makes an interesting topics appear unapproachable. And there are lecture notes which seem to skim over the really interesting details. And of course there is wikipedia, which isn’t exactly bad, but isn’t exactly good either. If that is you, then please read on and see if my contribution helps you at all.
LR Grammar Basics
A grammar is a set of rules for mapping between structured data and a linear representation of that data. The grammar can allow you to “produce” a linear form from a structure, or “parse” a linear form to recover the structure.
We use grammar whenever we convert thoughts and idea to sentences and stories. We use the same grammar in reverse when we convert sentences and stories that we hear and read back into thoughts and ideas. Of course the grammar of natural language is very complex and context-dependent, and each individual works with a slightly different version of the grammar. So the conversion of ideas to and from natural language is imperfect and error prone. It is however extremely powerful. It allows me to write this note, and you to get at least some of my ideas while reading it.
For computer languages we use much simpler but much more precise grammars. Noam Chomsky famously did a lot of work in formalising many ideas of grammar and it is him we thank for the “context free” grammars that work so well for programming languages.
A context free grammar (CFG) consists of a set of symbols and a set of productions. The symbols are grouped into two subset: the terminal symbols and the non-terminal symbols. There is one distinguished non-terminal symbol called the “start” symbol. The grammar describes a “language” which is the set of all possible “sentences” which in turn are lists of terminal symbols. It does this by giving rules for producing parts of sentences. Any sentence which can be produced following these rules is a valid sentence in the language. All other sentences are invalid. To avoid confusion, we normally reserve the word “produce” for when a single symbol produces a series of other symbols. Repeating this multiple times is a “derivation”. A complete derivation starts with the “START” symbol and results in a list of terminal symbols.
Terminal symbols are the elements of a sentence. These could be strokes of a pen, letters, words, or conceptual groups of words such as “noun” and “verb”. For the purposes of computer languages we normally work with “tokens” as terminal symbols where tokens are the things extracted by the scanner described in my previous note.
A grammar takes a sequence of tokens and groups them into semantic units such as expressions and statements. It essentially describes how to extract structure from a linear sequence of tokens.
“Tokens” here are little more than opaque objects represented by numbers. There is often extra detail combined with the number, but the grammar doesn’t care about that. If the grammar needs to know the difference between two things, they need to be different tokens. If it doesn’t then maybe they don’t need to be (though it doesn’t hurt).
The grammar describes how to gather sets of tokens (aka terminal symbols) together as what might be called “virtual tokens”. So the set of tokens “NUMBER PLUS NUMBER” might become a virtual token “EXPRESSION”. It can then be included in some other grouping of tokens. These “virtual tokens” are the things referred to earlier as “non-terminal symbols”.
A grammar uses these terminal and non-terminal symbol in the set of “productions”. Each production declares that some non-terminal symbol may produce a given list of symbols (whether terminal or non-terminal).
This terminology (‘start’ and ‘production’ and ‘terminal symbol’) doesn’t make much sense if you want to parse a program, but it does if you want to generate a program, or “sentence” as described earlier. From the perspective if generation, a symbol is “terminal” if it cannot generate anything more, and non-terminal if it can.
When we talk about parsing, we use the same terminology because that is what everyone else does. I would prefer “real tokens” for terminal symbols, “virtual tokens” for non-terminal symbols, “reductions” for productions and “goal token” for start symbol. But you gotta work with what you have.
LR parsing basics.
The process described above for generating sentences can process symbols in any order. Once you have more than one non-terminal you have a choice. You can produce something from the first, or from the second. So you could build up a sentence from the beginning, or from the end. When parsing you need to be more focused.
The “L” in “LR” means that parsing progresses from Left to right. You certainly could parse in some different direction, but the language you design for that sort of parsing would end up being very different. An “LR” grammar converts the leftmost groups of terminals into fewer non-terminals first and then progresses to include more and more terminals moving to the right.
We will get to the “R” shortly. I suspect that originally “LR” meant “Left to Right”. But there are two distinct ways to parse from Left to Right, one is recursive descent which requires a different sort of grammar to that described here – an LL grammar. For LR grammars you use a bottom-up shift/reduce parser.
This shift/reduce parser was invented by Donald Knuth and involves a state machine – with a bunch of states - a stack (of symbols and states) and two actions named “SHIFT” and “REDUCE”. One particular instance of “REDUCE” – the one that involves the START symbol – is sometimes referred to as “ACCEPT”. I see no value in making such a strong special case of that, so I keep just “SHIFT” and “REDUCE”.
If we think back to the previous description of deriving a sentence from the start symbol using the grammar, and consider the intermediate stages between “start” and the final sentence, then those lists of symbols (sometimes call “sentential forms”) are represented in the parser by the stack combined with the remainder of the input. The symbols from the bottom of the stack through to the top of the stack, followed by the “next” symbol to read from input through to the last symbol in the input correspond exactly to the sequence of symbols in some intermediate step when deriving the program.
The “production” step in sentence generation is exactly mirrored in the “REDUCE” step in parsing. Specifically if the top symbols on the stack match the symbols in the body of some production, then we might pop them off and replace them with the non-terminal which is the ‘head’ of that production.
The “SHIFT” step simply involves moving one terminal symbol from the input onto the stack. Parsing proceeds by shifting terminal symbols onto the stack until we have a set of symbols that can usefully be reduced, then reducing them. This continues until the entire program has been read (or “SHIFTed”). On each “REDUCE” step the parser will record information about the symbols that were popped so as to build up an abstract syntax tree which records the structure of the program. So each entry on the stack holds not just a symbol and a state, but also some record of what was parsed down to that symbol.
At every “REDUCE” step, the non-terminal that results is the right-most non-terminal in the interim sentence (because it is on the top of the stack, and everything further to the right is terminals still to be read). So if the series of steps that result from LR parsing were played in reverse as derivation, each step would involve producing something from the right-most non-terminal. This is where the “R” in “LR” comes from. The parse is the reverse of a “Rightmost derivation” from the grammar. This contrast with “LL” grammars where the parse follows a “Leftmost derivation”.
There is an important word above we needs special attention. It is “usefully” as in “until we have a set of symbols that can usefully be reduced”. It is important that after we perform the REDUCE step, the resulting interim sentence can still be derived in the language. So we always need to know what symbols are permitted at each stage in the parse. This is what the “state” of the state machine provides us with.
A “state” really belongs between two symbols. The “current” state is between the symbol on the top of the stack, and the next symbol to be read from the input. When we push a symbol onto the stack, we push the current state with it, so that when that symbol is later popped, we can collect the state that preceded it too.
LR parsing step by step
Now that we have the big picture, the best way to understand the details is to watch how the parsing works.
The data that we have are:
• The grammar, as a set of productions. Each production has a ‘head’ which is a non-terminal symbol, and a ‘body’ which is zero or more symbols, some may be terminal, others non-terminal. Each non-terminal may be the head of multiple productions, but must be the head of at least one.
• An ‘action’ table which is a mapping from a state plus a lookahead to an action.
The ‘state’ we have already introduced and will be described in more detail shortly. The “lookahead” is the next terminal to be read. As we need to be able to look at the next symbol, the parser is said to have a look-ahead of ’1′ and is sometimes written “LR(1)”.
The ‘action’ is either “SHIFT”, or “REDUCE(production)”. i.e. the “REDUCE” action must identify which production is being reduced. If the production has “START” as its head, then it is sometimes referred to as “ACCEPT”. Once the ACCEPT action happens we have parsed a complete sentence and must have finished.
• A “go to” table. This is a mapping from state and symbol to a new state. Whenever we push a symbol, whether due to a SHIFT or a REDUCE, we perform a lookup on the current state for the pushed symbol and that gives us the new state.
Given these data the parsing process is quite straight forward.
1. Start with an empty stack, with the “0″ state current, and with the first symbol from the input in the look-ahead buffer.
2. Look in the ‘action’ table for the current state and the symbol in the look-ahead buffer.
3. If the action is “SHIFT”, push the token and the current state onto the stack, look up the shifted symbol in the go to table for the current state, and save the result as the current state. Then go back to step 2. Note that we don’t actually need to store the symbol in the stack, but it can be useful for tracing.
4. If the action is “REDUCE”, see how many symbols are in the body of the reduced production, and pop that many entries off the stack. The state stored with the last entry popped becomes the current state. The entries popped must match the symbols in the production – the states will guarantee that. This is why we don’t really need to store the symbols.
Having popped those entries, we do any production-specific processing to build an abstract syntax tree and push the result on to the stack together with the current state (which was updated by the ‘pop’).
Finally we look up the current state and the head of the reduced production in the go to table and set the new state. Then if that reduced symbol was ‘start’ we finish, else we go back to step 2.
5. But what if the action table doesn’t contain an entry for the current state and the symbol in the look-ahead buffer? That means there is an error. The symbol is “unexpected”. We have to invoke the error handling procedure.
Error handling in an LR grammar
The easiest way to handle errors is just to throw our hands up in horror, report the error, and abort. But that is not always most useful. The preferred approach is to try to resynchronize with the grammar by throwing away a few symbols. Often the error will be localized and if we can just get past it we can start doing useful parsing again.
Some writers suggest synthesizing symbols as well as discarding them. For example you might guess that a semicolon was missing and so insert it. I don’t believe that idea adds anything useful. As you will see we do synthesise a single symbol which is the “error” token. Various error productions can be used to transform this into any nonterminal which may be needed. So while symbols might be inserted as well as deleted, that is just a side effect of the error productions in the grammar. The parser mainly focusses on discarding unusable symbols.
At the point where we detect an error there are two obvious symbols that could be discarded. We could discard the symbol in the look-ahead buffer, or the symbol on the top of stack. Or both. Or several in each direction. Ultimately we want to get to a situation where the state, possibly popped off the stack, has an action for the symbol in the look-ahead buffer. Choosing what to discard to get there cannot be done reliably without assistance from the language designer.
The language designer should “know” what the key structural elements and syntactic flags are. Some symbols will occur often and have a strong meaning, so aiming for one of those will be most likely to get back on track properly. The language designer can provide this information to the parser by specifying “error production”.
“Error” is a special terminal symbol that would not normally be found in the input stream. However it can appear in the body of a production and this makes it an “error production”.
A simple example is:
statement -> ERROR ";"
This says that an error followed by a semicolon can reasonably take the place of a statement. i.e. a semicolon is a strong syntactic symbol that nearly always means the end of a statement, even if there is garbage before it.
With a number of these error productions in the grammar, the task of error handling becomes quite easy.
Firstly the parser pops entries off the stack until the current state has an ACTION for ‘ERROR’. That mean it is a state which can cope with an error production. In the above example, it is a state which is expecting a statement.
Then the parser shifts in the ERROR symbol (updating the state with the appropriate ‘go to’) and then starts discarding input symbols until it finds one for which the current state has an action. At this point the parser is synchronized again and it can go on to perform the appropriate action as steps 2 and later above.
Building the tables
All that remains is to build the state table and the action table. These will require manipulating various sets, so you better dig something suitable out of you ADT library.
State and the go to table.
The purpose of the ‘state’ is to be a record of how we got to where we are. As there are a collection of states on the stack, the current state doesn’t need to be a complete record – a partial record can be sufficient. So as we build a description of each state we may need to throw away information. When we do that we must acknowledge it and be clear why that information can be discard.
“where we are” is at some point in some production. We have (hopefully) already seen some of the symbols in the body of some production, and we may have some more that we are expecting. However we could concurrently be at different points in different productions. This can happen in two ways.
Firstly, and most simply, if we are in the body of some production just before the non-terminal “X“, then we are simultaneously at the start of every production with “x” as its head.
Secondly, we may not yet know which of several productions we are in. There could easily be two or more productions that start with some set of symbols, but finish differently. While we are in that common prefix we need to assume that we are in all of the productions at once, and as more symbols become apparent, the number of possible productions we are in will decrease until it is just one. That will be about when we REDUCE the production into a non-terminal.
To model these ideas we define a “state” to be a collection of “items”. An item is a particular production combined with an offset in the body of that production. The offset is sometimes referred to as “DOT” so an item might be presented at:
expression -> expression "+" . term
This is a production which says that an “expression” can produce an “expression” followed by a “+” and then a “term”. Here the production has been made into an item by placing a “dot” which you can see between the “+” and the “term”.
This item says that we might be in the process of parsing an expression and have seen an expression and a plus sign. Of course we might be somewhere else where a “+” can follow an expression too, depending on what other items are in the state.
So a state is a collection of these items. They are all the possible positions in a derivation that we could be in. For all items in a state, the symbol immediately before DOT will be the same, unless DOT is at the start of the item. Other symbols might be different.
There are three different sorts of item, each important in their own way. They are distinguished by what follows the DOT.
A “completed item” has nothing following the DOT. DOT is at the end of the production. A “terminal item” has a terminal following the DOT. A “non-terminal item” has (you guessed it) a non-terminal symbol following the DOT. See if you can guess how each of these is used?
We find all possible states by a repetitive process which finds all possible “next” states from a given state, and keeps doing this to the known states until no more new states can be found.
The starting point of this search is the state formed from all productions that have the “start” symbol as the head. For each such production (normally there is only one for simplicity) we form an item with DOT at the start. This collection of items form the “zero” state, which is the state we start at when parsing.
Given a state we find other states by following a 2-step process.
Firstly we “complete” the state. For every non-terminal item in the state, we find all productions with that non-terminal as the head and add an item for each such production with DOT at the start (if that item isn’t already present). This effects the first way that we can have multiple items in a state.
Once we have added all possible “DOT-at-the-start” items we make a list of all symbols which follow “DOT” in any production. For each of these symbols we can potentially make a new state (though it is possible the state already exists).
To make a new state given a completed state and a symbol we discard all items for which DOT is not followed by the given symbol, and advance DOT forward one for all items where DOT is followed by the given symbol. If this state has not already been added to the state list, it must be added, otherwise the pre-existing state with the same set of items must be found.
For each symbol that produces a state from our completed state, we add an entry to the go to table, from the old state via the symbol to the “new” state.
As noted we discard items when creating a new state. This must be justified.
All the discarded terminal and non-terminal items will still appear in some other state which is created from the current one. So they aren’t lost, just elsewhere. This reflects that fact that as we consume more symbols from the input we narrow down the range of possible parses, so we must naturally narrow the breadth of the state.
The completed items which are discard are different. No matter which new state we go to, all of those items will be gone, so the history they record of how we got here will be gone too. However we still have it further up the stack. If the current state has dot at the end of a production, then the state on top of the stack will have dot before the last symbol in that same production, and the state below that will have dot before the second last symbol, and so now. Somewhere there will be DOT at the start of that production, and in that state will be recorded the production which lead to this one. And so up the production chain such that the first state which records the START production will still be on the stack, at the very bottom. So dropping these doesn’t loose any information as it is still on the stack.
Once we have applied the above 2-step process to all states, and doing it the the last state didn’t create any new state, we have a full set of states, and we have a complete go to table.
Hopefully the process of creating these states makes sense in the context of how the go to table is used during parsing. A single state records all the productions that could be happening at each point in the parse so far, and the set of states in the stack form a complete record of where we are up to, and what can happen next.
In particular, by examining the current state we can know what actions are possible at each different point. This information is used to construct the “action” table.
The Action table
To produce the action table for a particular state, we start by examining each of the items in that state. We have already done all that we can with the “non-terminal” items, so it is just the “terminal” and “completed” items that interest us now.
For each terminal item a reasonable action is to SHIFT the next input symbol if that symbol is the symbol after DOT. So all the symbols that appear after DOT are added to the action table with “SHIFT” as their action.
Note that it isn’t really necessary to store these in the action table. The “go to” table for that state has exactly the same set of terminal symbols in it (no more, no less), so we could instead look for the look-ahead symbol in the “go to” table. If it is present we assume the “SHIFT” action.
For each completed item, a reasonable action would be to REDUCE that particular production. But we don’t currently know how to store these in the action table – which look-ahead symbol to associate them with. Also it might be appropriate to REDUCE a production rather than SHIFT a new symbol.
It is in the different ways to address this question that the different flavours of LR grammars become apparent. So we will address a few of them individually.
LR(0) grammars
LR grammars are sometimes called LR(k) grammars where “k” is the number of symbols that we look-ahead in order to decide the next action. Most often LR(1) grammar are used.
An LR(0) grammar in one in which no look ahead is done. For this to work there must be no questions raised by any state. That is, a state may either have exactly one completed items, or some number of terminal items. It may never have both and may never have two different completed items, as these would require a decision and we have no look ahead and so no basis to make a decision.
LR(0) grammars are too simple to be really interesting. They require every production to end with a terminal which doesn’t occur anywhere but at the end of productions. So if every production was enclosed in brackets that would work. However that nearly limits LR(0) to Lisp, and Lisp doesn’t really need a shift/reduce parser at all.
So LR(0) grammars are interesting primarily as a starting point, not for practical use.
LR(0.5) grammars
This is a label that I made up myself, as I think it describes a useful set of grammars but I have not seen it described elsewhere. Where an LR(0) grammar uses no look-ahead, an LR(0.5) grammar uses one symbol of look-ahead, but only half the time. Look ahead can guide the choice whether to SHIFT or REDUCE, but not the choice of which production to reduce.
So for a grammar to be LR(0.5), each state may have at most one completed item in its item set. When that is the case, all terminal items cause a SHIFT entry for the appropriate terminal to be added to the Action table, and all other possible entries in the Action table are set to REDUCE the one completed item. If there is no completed item then all other entries in the Action table lead to error handling.
As before, you wouldn’t actually bother storing this Action table. You would just record the one REDUCE action as a default. Then if the look-ahead symbol is present in the go to table, the parser performs SHIFT, otherwise it performs the default REDUCE or triggers an error.
I have seen it suggested that a weakness of this approach is that it doesn’t detect an error at the earliest possible moment. We may have to wait for several reductions to happen until we hit a state with no possible reductions, and which does not have a ‘go to’ for the current look-ahead token. Again, I don’t really understand this logic – those reductions don’t consume any input symbols so the error is still detected at the correct place in the input text. But maybe I’ll understand better once I’ve had some more experience, so stay tuned.
In my experiments with a grammar for Ocean, I’ve found that I never have two completed items in the one state. So a grammar such as this could well be sufficient to parse the language I will end up with.
This highlights as important aspect of my focus here. I don’t particularly need a grammar parser that is suitable for any language I get handed. I just need a parser which will handle the language that I will develop. And I plan to develop a language with a very simple and regular syntax – one that is easy enough for a mere human to understand. So I don’t want a lot of complexity. So while LR(0.5) may not be good enough for a lot of use cases, it could still be good enough for me.
However it isn’t quite. Not because my language won’t be simple, but because LR(0.5) cannot tell me exactly how simple my language is.
This is a bit like the fact that a lot of syntax in programming language isn’t needed for correct programs. It is only needed for incorrect programs to help the programmer see exactly where it is incorrect. Similarly if I get my grammar right, then LR(0.5) should be enough. But if I get it wrong, I may not know if I only do an LR(0.5) analysis of it.
So I need more power in my grammar analysis and so must move on.
Precedence LR Grammars
This is a bit of an aside as Precedence grammars don’t help detect errors and inconsistencies in a grammar, they only help to fix them. However they are useful to understand and as this is where they fit in the progression of complexity, this is where I will discuss them.
The idea with a precedence grammar is that the designer can make extra statements about different productions, giving them different precedence. This can apply in two different ways.
Firstly it can be used to choose between two completed items in a state. If we are trying to treat a grammar as LR(0.5) and find that some state has two completed items, we can “fix” the grammar by specifying a precedence of the various productions. I’d like to give an example here but it would end up being a toy example of a completely useless grammar and so wouldn’t really help. I personally cannot see why you would ever want a grammar which had two completed items in the same state. It means that some sequence of input token could be treated as one thing or as another depending only on what comes next. That sounds a like a design mistake to me. Maybe I’ll eat my words later, but for now this means I cannot find a useful example – sorry.
The other way that precedence can be useful is much easier to explain. It concerns the choice between SHIFT and REDUCE. As noted above, an LR(0.5) will always SHIFT when it can, and only reduce when it cannot. That might not be what you want.
Here there is a classic example: expression parsing. Consider this grammar.
expression -> expression "+" expression
| expression "*" expression
A state in this grammar could have an item containing
expression -> expression "*" expression .
expression -> expression . "+" expression
That is, we have parsed an expression, a multiplication symbol and another expression, and how we are faced with a choice of REDUCING the multiplication to a single expression, or SHIFTing in a plus sign.
The mathematically standard thing to do would be to REDUCE as multiplication has higher precedence than addition. However the LR(0.5) grammar parser would shift by preference which would produce the “wrong” result. So this grammar is “wrong”, but is easily fixed by giving the multiplication production a higher precedence than the addition production. The grammar processing step would then notice that a REDUCE step has a higher precedence than the SHIFT, and would remove the SHIFTed symbol from the “go to” table.
In order to make repeated use of the same operations (e.g. “a + b + c”) group correctly (as “(a + b) + c”) we would also want to reduce an addition before shifting another plus sign. So a production in a “completed item” might need a higher precedence than the same production in a “terminal item”. To get a completely general solution, we required each precedence level to be left-associative or right-associative. If the former, then reduce beats shift. If the latter then shift beat reduce.
These precedences can be useful, but they aren’t really required. The same effect can be achieved with more non-terminals. For example
expression -> expression "+" term
| term
term -> term "*" factor
| factor
By giving different names to things that are added and things that are multiplied, and by putting different names on either side of the operations, the precedence and associativity can be specified implicitly and with complete generality.
Which of these forms you prefer is very much a subjective issue. There is little practical difference, so it is best to choose the one that makes most sense. I think I prefer the latter, though the former is briefer and that is not insignificant.
The one practical difference that exists is that the second form involves more REDUCE steps during parsing. Reducing
term -> factor
doesn’t really do much, but is a step which is completely unnecessary in the first grammar which needed precedence to disambiguate. So if you find your parser spending too much time reducing trivial productions, it might be useful to re-write it in a form that doesn’t require them.
SLR(1) Grammars
So far we have looked at what we can do with just the “go to” tables and some simple conventions or annotations. But it is possible to extract more details from the grammar itself and see if we can resolve some potential conflicts automatically.
The first of these is call “SLR” for “Simple Left-Right” grammar.
SLR(1) adds the computation of “FOLLOW” sets. For each non-terminal “s”, “FOLLOW(s)” is the set of all terminals which could possible follow “s” anywhere in any sentential form derived by the grammar. This is then used to build the ACTION tables.
When we have a completed item, we look at the symbol in the head of that item, find the FOLLOW set for that symbol, and for every terminal in the FOLLOW set, add an Action to REDUCE that production if the given terminal is the look-ahead symbol.
This will often clearly identify which symbols should trigger a reduction (and which reduction to trigger), and which symbols should be shifted. Consequently it also identifies which symbols are in error.
If there is any over-lap between the FOLLOW sets of reducible productions or between a FOLLOW set and the SHIFTable terminals, then the grammar is said to not be SLR(1). If there is no conflict, the grammar is fine and we have a well defined action table.
Computing the FOLLOW sets requires three simple steps.
Firstly we flag all the symbols that can produce an empty string. Normally relatively few symbols can do this, though any time you have a list that could be empty, you will need a “nullable” symbol (as these are called). These are found by an iterative process.
Firstly we flag all the non-terminals which are the heads of productions with no symbols on the right hand side. Then we flag all non-terminal were all the symbols on the right hand side are flagged. If there were any, then we repeat the process again and again until we cannot flag any more non-terminals as nullable. Then we can stop.
Having done this, we now proceed to the second step which is to build a FIRST set for every non-terminal. You can include terminals as well if it makes it easier, however the FIRST set for a terminal contains simply that terminal, so it is quite easy to make a special case of terminals.
“FIRST(s)” is the set of all terminal which could be the “first” terminal in an expansion of “s”. We compute this using a similar iterative approach to calculating “nullable”.
We walk through all the productions in the grammar and add to FIRST() of the head symbol, the FIRST set of every symbol in the body which is preceded only by nullable symbols. So the FIRST set of the first symbol on the RHS is always added, and the first set of the second symbol is too if the first symbol was flagged as being nullable. And so on.
We continue this process checking each production again and again until no more changes in the FIRST sets can be made. Then we stop.
Once we have the nullable flag and the FIRST sets we can proceed to the third step which is to create the “FOLLOW” sets. This again follows a pattern of repeating a partial calculation until no more change can be made.
To find “FOLLOW(s)” we find every occurrence of “s” in the body of any production, and add FIRST(t) where “t” is the symbol after “s”, or any symbol following “s”but only separated by nullable symbols. If all of the symbols following “s” are nullable, then we also add FOLLOW of the head of the production.
Adding the FIRST of following symbols only needs to be done once, as FIRST is stable and won’t change any more. Adding FOLLOW of the head might need to be done repeatedly as other changes to FOLLOW sets might need to flow back to this one.
Again, once we don’t find any more changes we can stop. At this point we have complete FOLLOW set and can determine if the grammar is SLR(1), and if so: what the action table is. If the grammar is not SLR(1), it might be fixable with precedence annotations.
LALR(1) grammars
SLR(1) grammars are pretty general but not completely so. If a non-terminal is used in two quite different parts of the grammar then it is possible that it is followed by different symbols in different places. This can result in it reporting conflicts that won’t actually happen in practice. This is because we have been too general in generating the FOLLOW sets, assuming that the FOLLOW set of any symbol is the same in every state. Often it is, but not always.
If we are going to bother generating FOLLOW sets, and particularly if we are doing it for the purpose of checking if there are any unexpected possible inconsistencies in the grammar, then we may as well do it properly. Doing it properly is called “LALR(1)”, where “LA” stands for “LOOK AHEAD”.
If you look in the literature you can find lots of different ways of calculating the LALR LOOK-AHEAD sets. Many of these start with the states we have from the LR(0) calculation and go from there. I don’t really like those – I find them confusing and they don’t really make it clear what is happening (without lots of head scratching). So I’m presenting my way of doing it. I didn’t find this in the literature, but maybe that is because I didn’t understand all that I read. I’m sure someone did come up with it before me.
This procedure requires the FIRST sets and the ‘nullable’ flag developed for the SLR grammars, so we will keep them but discard the FOLLOW sets. In place we will generate lookahead or LA sets, one for each item in each state. So LA(s,i) is a set of terminals which we expect to see after the item ‘i’ is reduced in or following state ‘s’.
If we go back to the description of items and state and go to table it is not hard to see in retrospect that we lost some information, at least if we were considering an LR(1) style grammar. We didn’t include the look-ahead symbols in our description of state, but now we must.
So: each item in a state is not only a production and an offset in the body of that production. It must now also contain a set of terminals which can follow after that production (i.e. after the body or, equivalently, after the head). For the items based on the “start” symbol that are used to populate the first state (state zero), the look-ahead set contain only the special “end-of-file” terminal.
When we complete a state by adding an item for each production from each non-terminal which follows “DOT”, we calculate the LA set for that item in much the same way that we calculated FOLLOW. We add together the “FIRST” sets for all subsequent symbols which are separated from the target non-terminal only by nullable symbols, and with use this sum of FIRST sets as the LA set of each item we make from that target non-terminal.
If all of the symbols following a non-terminal are nullable (or if there are no symbols following it), we need to add in the LA set for the source item.
So if an state contains the item:
A -> B C . D E {L}
Where “{L}” is the look-ahead set, then when we add an item based on a production with “D” in the head, the look-ahead set must be set to FIRST(E), and if E is nullable, this must be unioned with “L”, so
D -> X Y Z { FIRST(E) + L}
When we create a new state using selected items from an old state, the LA sets simple get copied across with them.
Now we come to the interesting part. If you look back at how we generate state before you will recall that each time we generated a new state we had to check if it was in fact new, or if it has been seen before. If it has been seen before we just reused the old state.
Now that we are carrying extra information in a state we need to know what to do with that. There are two options.
Firstly, we can decide that the look-ahead set is an important part of the state (which it is) and so if the look-ahead sets are different, we have to create a new state. This will mean that, in general, the LALR process will create more states than the LR(0) or SLR(1) processes. Often many many more. If you choose this approach you actually end up with “canonical LR(1)” which is described next. So let’s not get ahead of ourselves.
If you decide that while important, the look ahead sets shouldn’t justify making new state, then you can instead update the old state by adding in (i.e. set-union) the LA sets of the new state with those of the old state. This loses a little bit of information and so there can be grammar which will end up with conflicts after the LALR process, but which will work fine with canonical LR(1). But in many cases there won’t be conflicts, so LALR is enough.
As we have updated the LA sets of a state, and as the LA sets can propagate through to other states, we need to re-process every state where we changed the LA set. This can result if processed each state twice or even more on average. It appears to be only a constant increase in effort, so should not be too burdensome.
After we have generated all the new states, and propagated all LA set changes as far as they will go, we have complete LALR(1) LR sets from which we can form action tables.
Again, these might result in completely unique actions for each terminal, or might result in conflicts. If the former, we say the grammar is LALR(1). If the latter, it is not.
LALR(1) usually provides enough power without too great a cost and seems to be the best trade off. As noted I am most interested in LALR not for the high quality action tables it produces (I don’t want to use them) but for the fact that it will calculate the LA sets and tell me if there are any cases were both a SHIFT and a REDUCE might be appropriate, and can provide extra information to tell me why a state might have to different possible REDUCE actions. This information will, I think, be invaluable in understanding the grammar as I am creating it.
Canonical LR(1) grammars
The “canonical LR(1)” style of grammar is the original one described by Knuth before others found ways to simplify it and make it more practical. For LR(1) “usefully” (as in “until we have a set of symbols that can usefully be reduced”) requires a lot more states that “LR(0)” and all the intermediate forms. These state reflect the various different possibilities of look-ahead and generally aren’t very interesting.
There certainly are grammars which are LR(1) but not LALR(1), but I don’t think they are very interesting grammars. Still they might be useful to some people.
The only conflicts that LALR(1) will report but with LR(1) will know are false conflict a REDUCE-REDUCE conflicts. i.e. two different reducible productions in the same state. As I have already said I think this is a design mistake so I have no use at all for LR(1). If LALR(1) reports a conflict, then I think it is an error even if it is not really a conflict.
To construct the states for LR(1) we follow the same approach as LALR, including an LA set with each item in each state. However when we look to see if a new state already exists, we require that both the core items and their LA sets are identical. If they are, then it is the same LR(1) state. If not, we need a new state. No merging of LA sets happens, so we don’t need to repeatedly process each state.
This produces more states. I have one simple grammar which results in 27 LALR(1) states and 55 LR(1) states. I have another I’m playing with which currently has 174 LALR(1) states and 626 LR(1) states.
An Implementation.
Theory is never really interesting without practical implementation to show how it works. One of the great appeals of computer programming is that creating practical implementations is quiet easy (unlike economics for example, where experimenting with national economies requires way too much politics!)
So I have written a parser generator that realises all this theory. It can use any of the different analysis approaches listed above. The generated parser only uses LR(0.5) though. I don’t bother building a list of reducible productions and choosing between them based on look-ahead as I don’t think this will ever actually be useful.
Also the generator does not yet handle precedence annotations. The annotations can be given by they are ignored. I simply ran out of time and wanted to get this published before yet another month disappeared. I hope to add the precedence handling later.
The link above is to the version as it is today. I have other plans to enhance it as will be seen in my next post but I wanted the code linked here to represent only the ideas listed here.
If you want to try this out, you can:
git clone git://ocean-lang.org/ocean
cd ocean/csrc
make; make
./parsergen --LALR calc.cgm
./parsergen --LR1 calc.cgm
This will print a report for the grammar showing all of the states complete with items and LA sets. This might help with following the above explanation which is, a some points, a little dense.
Note that if you want to create your own grammar, you need a “markdown” formatted file prepared for `mdcode` processing. Hopefully `calc.cgm` is a usable example.
Posted in Language Design | Leave a comment
Lexical Structure
It is traditional to divide the parsing of a program into two conceptually separate stages – the lexical analysis which extracts a stream of tokens from a stream of characters, and the grammar matching stage which gathers those tokens into grammatical units such a declarations, statements, and expressions. Recognising the value of tradition, Ocean will similarly have separate lexical and grammatical stages. This note will focus on the lexical stage.
Future language design decisions will refine may details of the lexical structure of the language, however there is a lot of commonality among current languages and we can build on that commonality to establish a base approach to lexical analysis which can then be fine tuned when the details of the language are known.
This commonality suggests that the grammars of programming languages are comprised of identifiers, reserved words, special symbols, numeric literals, and string literals. Comments need to be recognised but don’t form tokens for the grammar. White space is mostly treated like comments – recognised but not tokenised. However line breaks and leading indents sometimes are significant in different ways, so we need to decide whether and how they might be significant in Ocean.
Identifiers
Identifiers are mostly strings of letters and digits, though they don’t start with a digit. Sometimes other characters are allowed. This pattern is most easily summarised as a set of characters that can start an identifier and another set of characters that can continue an identifier. Fortunately Unicode provides well defined character classes “ID_Start” and “ID_Continue” which are suitable for exactly this purpose, providing we base the language on Unicode.
While ASCII was the old standard and is still very useful, Unicode does seem to be the way of the future and it would be foolish to ignore that in the design of a new language. So an Ocean program will be written in Unicode, probably in the UTF-8 encoding (though that is an implementation detail) and will use ID_Start and ID_Continue as the basis for identifiers.
Beyond that it may be desirable to add to these character sets. ID_Start does not contain the underscore which many languages do allow. Neither contain the dollar sign which, for example, Javascript allows in identifiers.
At this stage it seems best to decide that the lexical analysis engine should take a list of “start” characters and a list of “continue” characters to be added to ID_Start and ID_Continue, which can then be used to create identifiers. ”start” will contain at least the underscore. The fate of ‘$’ and any other character will have to await future language decisions.
Reserved Words
Reserved words are a specific subset of the class of words that can be used as identifiers. They are reserved for grammatical use, such as “if” and “while” and “else”. We cannot know at this stage what the list will be, just that there will be a list which will need to be provided to the lexical tokenizer. These words must only contain valid identifier characters.
Special Symbols
These are like reserved words, but they are made up from characters other than those used in identifiers (or those which mark numbers and strings which come later). One could imagine having tokens which combine identifer-characters and non-identifier characters, such as “+A”, but that seems like a bad idea. It is more natural to see that as two tokens “+” and “A”, and to let the grammar join them together as needed.
There is an important difference between reserved words and special symbols. Words that aren’t reserved can still be valid identifiers, while symbols that aren’t special are probably illegal. So if “while” is a reserved word but “whilenot” isn’t, then the later is simply an unrelated identifier. However if “=” is a special symbol and “=/” isn’t, then the later is not valid as a single token at all, and we must parse it as two tokens “=” and ”/”.
So for identifiers and reserved words, we take the longest string of characters that is valid for an identifier and then decide if it is actually a reserved word. For special symbols we take the longest string of characters which is a valid symbol and stop the current token as soon as we see a character which would not result in a valid token. Thus any prefix of a special symbol must also be a special symbol. This should not be a hardship as longer symbols are only chosen when the length is needed to distinguish from something shorter.
So together with the list of reserved words, the lexical engine will need a list of special symbols. These will probably be ASCII rather than full Unicode. While permitting Unicode is important, requiring it would probably be inconvenient.
Numeric literals
There are two questions we need to resolve for numeric literals: what character strings can be used, and what do they mean. We only need to answer the first here, but it might be useful to dwell a little on the second too.
I really like the idea in the Go language that numeric literals don’t carry strong type information. They are primarily a value and a value can be used where ever the value fits. So “1e9″ and “4.0″ might be integers, and ”34″ might be a float. I intend to copy this idea in Ocean and possibly carry it even further so that “34″ and “34.0″ are completely indistinguishable to the rest of the language (Go can see a difference in a some cases).
Given my principle that any feature available to built-in types should also be available to user-defined types, it follows that if a numeric literal might be useful as an integer or a float, it should also be usable for any other type. An important example is the “complex” type which might benefit from literal constants. To express these fully we need to distinguish the “real” from the “imaginary” components and this is typically done using a trailing ‘i’ or ‘j’.
Generalising this suggests that a numeric constant should allow a short suffix which can be used by user-defined types in arbitrary ways. The exact details of this will have to be left for a later stage of the language design. For now, numeric constants will be allowed 1 or 2 following letters, which as yet have an unspecific meaning.
There is plenty of precedent to follow for the numeric part:
• “0x” means that the following digits are is hexadecimal.
• “0b” means following digits are binary.
• A leading “0″ implies octal, unless there is a decimal pointer or exponent.
• An exponent is “e” or “E” followed by a decimal number which multiplies the preceding number by ten to the given power.
• A “decimal point” can be use to specify a floating point number.
Not all of this precedent is necessarily useful though. In particular the leading “o” meaning “octal” is an irregularity in the design as it is really “a leading 0 followed only by digits”. This usage is also error prone as regular mathematics ignores leading zeros. So Ocean will follow Python 3 and other languages and use “0o” for octal, making a leading zero only legal when followed by an ‘x’, ‘o’, b’, or ‘.’.
Other possibilities don’t have such strong precedents but are still useful. For example, “ox” can also introduce a floating pointer number of a hexadecimal point, or a “pNN” suffix gives a power of 2. There is also the question of whether a decimal point can start a number, or whether a digit is required.
Another possibility to add to the mix is that as long strings of digits can be hard to read it is sometimes permitted to insert underscores to aid readability, much as spaces are often used when writing large numbers in natural-language text. Some languages allow the underscores anywhere, others impose stricter requirements. For example in Ceylon a decimal number can only have them every 3 digits, and in hexadecimal or binary they can be every 2 or ever 4 digits.
Finally, some languages allow negative literals, whether by including a leading “-” in the number token, or by allowing a leading “_” to mean a negative literal.
To meet the goal of being expressive, Ocean should allow as many different ways to encode numbers as could be useful. To meet the goal of minimising errors, it should exclude possibilities that could be confusing and don’t actually add expressivity.
So Ocean will allow “0x” hexadecimal numbers, “0o” octal numbers, and “0b” binary numbers, with or without a “decimal” point and a “p” exponent, and decimal numbers with or with a decimal point and an “e” exponent. A decimal can only start with a zero if that is immediately followed by a decimal point and in that case the zero is required: a number cannot start with a point. The ”p” or “e” exponent marker can also be “P” or “E”, and the number following it is in decimal, with no leading zero, but possibly with a leading + or -.
As this is an experiment as much as a language I will try allowing the use of a comma for the decimal marker as well as a period. This means that commas used in lists might need to be followed by a space. Requiring that is a bit ugly, but actually doing it is always a good idea. If this turns out to be problematic it can be changed.
All of these can have single underscores appearing between any two digits (including hexadecimal digits). As another experiment, spaces will be allowed to separate digits. Only a single space (as with underscores) and only between two digits. Though this might seem radical it is less of a problem than commas as numbers are almost always followed by punctuation in a grammar.
All numeric literals are non-negative – the grammar will allow a prefix negation operator which will be evaluated at compile time.
This numeric part will be evaluated precisely such as can be achieved with the GNU “libgmp” bignum library. Conversion to machine format will only happen at the last possible point in language processing.
String Literals
String literal are simply arbitrary sequences of characters surrounded by some quote character. Or at least, almost arbitrary.
It can improve language safety to not allow literal newline characters inside string literals. Thus a missing close quote is easily recognised. When multi-line string constants are required, one effective approach is the triple-quote used by Python and other languages. This is common and well understood, so Ocean will borrow the idea.
Inside a string, escapes may or may not be permitted. These are typically a back slash (“\”) followed by one or more characters. The minimum requires would be “\n” for a newline, “\t” for a tab, and “\ooo” with octal digits for an arbitrary ASCII character. We could go to extremes and allow “\U{Name of Unicode Character}” which allows the use of long Unicode character names.
This is an area where extension might be useful so it is important that any construct that might be useful in the future should be illegal at first. So all escapes not explicitly permitted are in error.
One particular feature of strings that I personally have never liked is that to include a quote inside a quoted string, you escape the quote. This means that the simple rule “characters between quotes make a string” doesn’t apply and any parsing engine must recognise the escape character. As this is my language I will chose that quotes cannot be escaped. Instead Ocean will allow “\q” which will expand to whichever quote character starts and ends the string.
The escape sequences understood will initially be:
• “\\” – the “backslash” escape character.
• “\n” – newline
• “\r” – return
• “\t” – tab
• “\b” – backspace
• “\q” – quote
• “\f” – formfeed
• “\v” – vertical tab
• “\a” – alert, bell.
• “\NNN” – precisely 3 octal digits for an ASCII character (0-377)
• “\xNN” – precisely 2 hexadecimal digits
• “\uXXXX” – precisely 4 hexadecimal digits for a Unicode codepoint.
• “\UXXXXXXXX”- precisely 8 hexadecimal digits for a Unicode codepoint.
There are three quote characters that are sometimes used: single quote, double quote, and back quote. Ocean will almost certainly allow all three. The lexical analysis code will certainly recognise any of the three that haven’t been claimed as a special symbol. Though I’m leaving this open at present, I expect that strings surrounded by backquotes will not have any escape processing done, while the other strings will.
If two quote symbols appear together, that is simply an empty string. If three appear, then it is a multi-line string. The next character must be a newline and the closing triple quote must appear on a line by itself. The newline after the first triple quote is not included in the string, the newline before the second triple quote is.
Quoting is permitted inside multi-line strings in the same way as with single-line strings, so triple-backquote should be used to avoid all escape interpretation. In a multi-line string that allow escapes, an escape character at the end of the line hides that newline character. This is the only way to achieve a multiline string that does not end with a newline character.
With multi-line strings comes the question of indenting. It would be nice to be able to indent the whole string to line up with surrounding code, and to have the indent stripped when the parsed token is turned in to a string constant. But the key question is : how exactly to specify what to strip.
One option would be to strip the same indent as was on the line that contains the start of the token. However it is nice for values to be more indented than – say – the assignment that uses them.
Another option would be to strip the same indent as was on the line that contains the end of the token. This places the programmer in more control and probably makes lots of sense. It would only be safe to strip the exact sequence of characters that precede the close quote. So if there is a mix of tabs and spaces, it must be the same mix for every line.
I’m not 100% comfortable with this, but it is certainly worth a try, so it will be how the first attempt works.
Comments
There are three popular styles of comments:
• /* Block comments from C and others */
• // single-line comments from C++ and BCPL
• # single-line comments from C-shell and Bourne shell.
While others exist, these seem to be most popular, and others don’t add any extra functionality. For the block comment, it is important to note that nesting is not permitted. That is: the character pair “/*” may not appear inside a comment. Allowing it does not significantly improve expressivity, and excluding it guards against forgetting or mis-typing the closing sequence “*/”.
It seems best to simply allow all of these forms of comments. The only negative impact this might have is that it means the 3 introductory notations could not be used elsewhere, and of these, the “#” is the only symbol with significant uses in existing languages. Where it is used, it is often for extra-language functions such as macro pre-processing. Features provided by these extra-language notations are probably best included in the main language in some way. So at this stage, the plan for Ocean is to treat all three of these forms as comments.
Line breaks and indents
The use of context-free grammars to describe languages led to line breaks being largely ignore as syntactic elements. Rather a program is seen as a linear sentence in the language, and spacing it just used to improve readability.
However this approach allows the possibility of the visual formatting becoming out-of-sync with the actual structure of the program. Further it results in syntactic elements, particularly semicolons, which are required by the language but appear unnecessary to the human reader.
Various approaches to address this have been tried in different languages. Of these I find that in Python the nicest. It may not be perfect, but recognising both the presence of line breaks and the level of indents seems valuable.
We will explore this issue more deeply when we look at using a grammar to parse the token sequence, but for now we need to know what tokens to include, and what they mean.
The key observation needed at this stage is that when a block of text is indented, it is somehow subordinate to the preceding line that was not indented. Thus that first line doesn’t completely end until all the indented text has been processed.
So every line break will generate a “newline” token, however if subsequent lines are indented, the “newline” token will be delayed until just before the next line which is not indented. Together with this, “Indent” tokens will be generated at the start of each line which is indented more than the previous line, with matching “Undent” tokens when that indent level terminates. In consequence of this, indenting can be used to bracket syntactic objects, and to whatever extent newlines terminate anything, they only do so after any indented continuation is complete.
So for example
if A
and B {
X
Y
while C do
Z
}
would parse as
if A INDENT and B { INDENT X NEWLINE Y NEWLINE while C do INDENT Z
NEWLINE UNDENT NEWLINE UNDENT NEWLINE UNDENT NEWLINE } NEWLINE
Note that INDENT and UNDENT come in pairs, and the NEWLINE you would expect before an INDENT comes after the matching UNDENT. This will allow a multiple UNDENT, such as that following the “Z” to terminate a number of syntactic units.
Interaction with literate programming
As previously discussed an Ocean program is, at least potentially, presented as a literate program which may have several code blocks from various parts of the document. The above discussion of lexical analysis has assumed a simple sequence of characters, while in actual fact with have a sequence of blocks of characters. Does that make a difference?
As blocks are always terminated by newlines, and as indenting is carefully preserved across blocks the only issues that could arise would be with lexical elements which are contain newlines, but aren’t newlines themselves. Of these there are two.
Firstly, block comments can contain newlines. Therefore, is it acceptable for a comment that starts in one code block to be continued in another? Almost certainly this would be a mistake and would lead to confusion. It is possible that it might be useful to “comment out” a block of code, however it that is important, then the language should have more focused means to achieve the same without confusion. Our literate programming syntax make it possible to mark a block as an “Example” to not be included in the code, and a section reference line can easily be commented out with a single-line comment. So comments must not span literate program code blocks.
Secondly, multi-line strings can contain newlines. For much the same reasons as with comments, these strings will not be permitted to span literate program code block. The fact that we strip the indent of the closing quote from all lines makes interaction with literate programming much cleaner than leaving all the indentation in.
Trying it out.
Having lots of ideas without any code isn’t much fun. So to accompany this blog is my first release of a token scanner – written as a literate program of course.
It is somewhat configurable so that if I change my mind about spaces in numbers they are easy to remove.
This program is one of the reasons that this post took so long to arrive. I had written a scanner prior to staring in the post, but wanted to re-write it as a literate program and wanted to incorporate ideas I had gained since writing it. This took quite a while as I’m still new the the literate programming approach and my first draft had a rather confused structure. However I’m really happy with the result and I think the code and design are better for the extra effort put in.
Posted in Language Design | 4 Comments
Literate programming?
I was going to start out by describing the lexical structure of Ocean, but as I thought more about it, I realised there was something that needed to come first. And that something is literate programming.
Literate programming is the idea – popularised by Donald Knuth – of writing programs like pieces of literature. They can be structured as a story or an exposition, and presented in a way that makes sense to the human rather than just to a computer.
The original implementation – known as “web” with two tools, weave and tangle – took a source document and converted either to TeX for elegant printing, or to Pascal for execution. So the “web” input was not read directly by the compiler.
I first came across the idea of the language being prepared for literate programming with the language “Miranda”. A Miranda program can come in a form where most text is treated as comments, and only suitably marked pieces of text (with a “>” at the start of the line) is treated as code. I like this idea – the language should acknowledge the possibility of literate programming from the start. I want Ocean to acknowledge it too.
Obviously a language cannot enforce a literate style, and I don’t think I would want it to try. I am a big believer in “write one to throw away”. The first time you write code, you probably don’t know what you are doing. You should consider the first attempt to be a prototype or first draft, and be ready to throw it away. There probably isn’t a lot of point trying to weave a prototype into a story.
But once you have working code and have got the algorithms and data structures sorted out in your mind, I think there is a lot of value in re-writing from scratch and presenting the whole more clearly – as a piece of literature. So I see two sorts of programs: prototypes that just have occasional comments, and presentation code which is written in full literate style. I find that having an audience to write to – even an imaginary one – motivates me to write coherently and close the gaps. Presenting code as a piece of literature may equally motivate good quality.
Having two different forms at first suggested to me the idea of two different file suffixes to maintain a clear different, but I no longer lean that way. It might be nice to allow two different suffixes so a programmer could create “hello.ocd” – the “OCrean Draft” first, and then create “hello.ocn” the final program as a separate file, but having the compiler impose different rules on the two files would likely make programmers grumpy, or at least confused. So as long as there is a simple syntax marker at the top of the file which effectively says “this is all code”, that should be all that the compiler needs to care about.
The key elements of literate programming are to have a language for presenting the text, a way to extract the code from among that text, and some sort of cross-reference mechanism for the code.
This last is important because presenting code as a story doesn’t always follow a simple linear sequence – it is good to be able to jump around a bit. We might want to tell the overall story of a function, then come back and explain some detail. The extra detailed code should appear with the extra detailed explanation. It may be possible to use language features to do this, but at this stage of the design I am far from certain. So I want the literate-programming model to allow rearrangement of code through cross references.
While TeX has many advantages for presenting text and produced beautiful output, I do find it a bit clumsy to use. It is maybe too powerful and a little bit arcane. A popular language for simple markup currently is “markdown”. The input is quite easy to read as plain text, and there are plenty of tools to convert it into HTML which, while not particularly elegant, is widely supported and can be tuned with style sheets.
“markdown” has the added advantage of have a concept of “code blocks” already built in so it should be easy to extract code. Using “markdown” for literate programming is not at all a new idea. A quick search of the Internet finds quite a few projects for extracting executable code from a markdown document. Several of them allow for cross references and non-linear code extraction, but unfortunately there is nothing that looks much like a standard.
This lack of a standard seems to be “par for the course” for markdown. There is some base common functionality, but each implementation does things a bit differently. One of these things is how code sections are recognised.
The common core is that a new paragraph (after a blank line) which is indented 4 or more spaces is code. However if the previous paragraph was part of a list, then 4-spaces means a continuation of that list and 8 spaces are needed for code. In the Perl implementation of markdown, lists can nest so in a list-with-a-list, 12 spaces are needed for code.
Then there are other implementations like “github markdown” where a paragraph starting with ``` is code, and it continues to the next ```. And pandoc is similar, but code paragraphs start with 3 or more ~~~ and end with at least as many again.
On the whole it is a mess. The github and pandoc markings are probably unique enough that accepting them won’t conflict with other standards. However while the Perl markdown recognises nested lists, the python markdown doesn’t. So code extracted from markdown written for one could be different from markdown written for the other.
But if I want Ocean language tools to be able to work with markdown literate programs (and I do) then I need to make some determination on how to recognise code. So:
• A paragraph starting ``` or ~~~ starts code, which continues to a matching line
• An indented paragraph after a list paragraph is also a list paragraph.
• An indented (4 or more spaces) paragraph after a non-list paragraph is code
This means that code inside lists will be ignored. I think this is safest – for now at least. If experience suggests this is a problem, I can always change it.
This just leaves the need for cross-references. Of the examples I’ve looked at, the one I like that best is to use section headings as keys. markdown can have arbitrarily deep section headings so a level 6 or 7 section heading could cheaply be placed on each piece of code if needed. So I’ll decide that all code blocks in a section are concatenated and labelled for that section.
While cross references are very valuable, it can sometimes be easier to allow simple linear concatenation. An obvious example is function declarations. Each might go in a separate section, but then having some block that explicitly lists all of those sections would be boring. If anything, such a “table of contents” block should be automatically generated, not required as input. So it will be useful if two sections with the same, or similar, names cause the code in those two (or more) sections to be simply concatenated.
It is unclear at this stage whether it should be possible to simply reuse and section heading, or whether some sort of marker such as (cont.) should be required. The later seems elegant but might be unnecessary. So in the first instance at least we will leave such a requirement out. Section names for code can be freely reused.
Inside a code block we need a way to reference other code blocks. My current thinking is that giving the section name preceded by two hash characters (##) would be reasonable. They are mnemonic of the section heading they point to, and are unlikely to be required at the start of a line in real code.
These references are clearly not new section headings themselves as they will be indented or otherwise clearly in a code block, where as section headings are not indented and definitely not in code blocks.
So this is what literate Ocean code will look like: markdown with code blocks which can contain references to other code blocks by giving the section name preceded by a pair of hashes.
A non-literate Ocean file is simply one which starts with ``` or ~~~ and never has a recurrence of that string.
To make this full concrete, and as a first step towards working code in which to experiment with Ocean, I have implemented (yet another) program to extract code from markdown. Following my own advice I wrote a prototype first (in C of course, because I can’t write things in Ocean yet) and then re-wrote it as a literate program.
I found that the process more than met my expectations. Re-writing motivated me to clean up various loose ends and to create more meaningful data structures and in general produced a much better result than the first prototype. Forcing myself to start again from scratch made it easier to discard things that were only good in exchange for things that were better.
So it seems likely that all the code I publish for this experiment with be in literate style using markdown. It will require my “md2c” program to compile, until Ocean is actually usable (if ever) in which case it will just need to Ocean interpreter/compiler which will read the markdown code directly.
I find that my key design criteria of enhancing expression and reducing errors certainly argue in favour of the literate style, as the literate version of my first program is both easier to understand and more correct than the original.
This program can be read here or downloaded from my “Ocean” git repository at git://ocean-lang.org/ocean/.
Posted in Language Design | Leave a comment
The naming of a language
“The naming of cats is a difficult matter, It isn’t just one of your holiday games.” The naming of programming languages is also important. As with any project a name is needed to be able to refer to, and it inevitably will set expectations and flavour to some degree.
I’ve had a few different thoughts about names. My first idea was “plato”. Plato was a philosopher and is particularly known for drawing a distinction between the real and the ideal. All things in the real world, circles and squares and so forth, are just poor shadows of the perfect circles and the perfect squares that exist in the ideal, or “Platonic” plane.
I actually think Plato had this backwards (though I haven’t read his work so quite possibly misunderstand him and misrepresent his ideas here). To my mind the ideals that we think about are poor approximations to the real world which, after all, is the reality. The process of thinking (which is what philosophy tries to understand) involves creating abstractions that map on to real world objects and events, and in trying to find the abstractions that are both general enough to be useful, and precise enough to be truthful.
I see the role of a programming language being to fill exactly this gap. It needs to address real world problems and tasks, but does so by generalising and abstracting and treating them mathematically. In a sense the program exists in the Platonic plane while the implementation exists in the real world, and the language has to ensure effective communication between the two.
So “plato” is not a bad choice, but it isn’t the one I’m going to use. I actually think “plato” would be a great name for a “platform” – like “Android” or “Gnome” or whatever. They both start “plat”…
My next thought was to name it “Knuth” after Donald Knuth who has had some influence of my thinking as you will see in future articles. The naming of language after dead mathematicians has some history (with Pascal and Ada at least), but as Mr Knuth is still alive, using the name “Knuth” doesn’t fit that pattern. And it would probably be a bit pretentious to try to use such a name for a little project such as this. So that name is out.
While dwelling on my real motivation for this language, I realised that it really is quite strongly influenced by my personal experience of the last few decades of programming. This should be no surprise, but it is worth acknowledging. It is easy to pretend that one is being broad minded and considering all possibilities and creating a near-universal design, but that is only a pretence. The reality is that our values are shaped largely by our past hurts, and these can only come from our past experience. I must admit that I am escaping from something, and that something is primarily “C”.
I’ve used C quite happily since the mid ’80s and enjoyed it but have always been aware of deficiencies and it is really these that I want to correct. I’ve watched other language appear and evolved and there have been good ideas but I’ve not found any really convincing. Python has a lot going for it and I tend to use it for GUI programming, but when I do it just reminds me how much I like static typing.
So this language is to be my escape from C (at least in by dreams) and should be named as such.
C is seen to be a successor of B, which in turn grew out of BCPL. So the joke at one time was to ask whether the next language could be “P” or “D”. Of course it turned out to be “C++”, a joke of a different kind. And then “D” came along anyway.
What do I want to call my successor of “C”? The answer is easily “Ocean”. Oceans are critical to life in many ways, but dangerous too – they need to be understood and tamed. Oceans are big and wide with many unknown and unexpected inhabitants. If I want an arbitrary name for something else related to “Ocean”, I can use “Pacific” or “Indian” or “Atlantic”. And of course an “Ocean” is like a “C”, but more so.
Having admitted that Ocean will follow on from C in some ways, I should explore a little what that means.
Primarily it means that Ocean will be a compilable language. I’m not at all against interpreting and JIT compiling but I don’t like to require them. The runtime support code should not need to include an language parser, unless explicitly requested. This means for example that a function like “eval”, which can be given some program text is completely out. Similarly interpolating variable names into strings with “…${var}…” is not an option.
Some degree of introspection is probably a good idea – I haven’t really decided yet – so it may be possible for a program to manipulate language objects. But this must not be part of the core language and it should only exist as a library for programmers with particular needs who are willing to pay the cost.
It also means that the programmer should have a lot of control. I’m not sure exactly what this means yet, but in general the programmer should feel fairly close to the hardware, and have an easy clear idea of when runtime support with help out and when it will stay out of the way. Certainly the program should have a fairly clear idea about how their constructs use memory and use CPU.
Static typing is a “must have” for me. This is essential for the compiler to be able to find bugs, and I trust compiler coverage a lot more than test coverage (though that is important too). There is certainly room for runtime type flexibility such as variant records, or values which can be real or NULL. These need to be available, but they should not be the default.
So that is what C means to me: static typing, compilable, and fine control. And that is what “Ocean” must contain – at least.
Now to be fair I must address the question of whether and these early design decisions fit with my philosophy stated early – particularly aiding clarity and minimising errors.
Static typing is almost entirely about minimising errors. By having types declared that the compiler can check, fewer mistakes will make it to running code. The equally enhance clarity by making clear to the reader what type is intended for each value.
“Fine control” is sufficiently vague that it could mean anything. I justify it by saying that it allows clear expression of precise low-level intention.
“compilability” really hinges on the lack of “eval”, though static typing is often related. “eval” effectively permits self-modifying code, and this is extremely hard for the compiler to assert anything concrete about at all. So I feel fairly comfortable asserting that “eval” is a great way to introduce hard-to-detect errors, so it should be avoided where possible. If some limited for of “eval” turns out to be particularly valuable, that can certainly be revisited when the time comes.
So while my language has no content, it now has a name: Ocean, and even a website: http://ocean-lang.org/. Anything could happen next… but it will probably be something lexical.
Posted in Language Design | 3 Comments
An exercise in Language Design
When I was doing my honours year in Computer Science (UNSW, 1986) I wanted to design a new programming language. That would be a rather large project for an honours year and naturally it didn’t happen. I have remained interested in languages, though for most of the time that interest has been idle.
I recently wrote some articles about languages for LWN and that has re-awoken my interest in language design. While I had scribbled down (or typed out) various notes about different ideas in the past, this time I seem have have progressed much further than ever before. It probably won’t ever amount to much but I’ve decided to try to continue with the project this time and create as concrete a design and implementation as I can … in my spare time.
As part of this effort I plan to write up some of my thoughts as blog entries, and publish some source code in a git tree somewhere. This note is the first such entry and it presents the high level design philosophy that I bring. Undoubtedly this philosophy will change somewhat as I progress, both in clarifying the ideas I present here and in distilling new ideas from all the reflection that will go into the design process. I’ll probably come back and edit this article as that happens, but I’ll try to make such changes obvious.
Philosophy
I see two particular goals for a language. This first is allow the programmer to express their design and implementation ideas clearly and concisely. So the language must be expressive. The second is to prevent the programmer from expressing things that the didn’t mean to express, or which they have not thought through properly. So the language must be safe.
There are a number of aspects to being expressive. Firstly, useful abstractions must be supported so that the thinking of the programmer can be captured. “useful” here is clearly a subjective metric and different abstractions might be useful to different people, depending on what they are familiar with. Some might like “go to”, some might like “while/do”, other might like functions applied to infinite sequences which are evaluated lazily. The language I produce will undoubtedly match my own personal view of “useful”, however I will try to be open minded. So we need clear, useful abstractions.
The “what they are familiar with” is an important point. We all feel more comfortable with familiar things, so building on past history is important. Doing something in a different way just to be different is not a good idea. Doing it differently because you see an advantage needs to be strongly defended. Only innovate where innovation is needed, and always defend innovation clearly. When innovation is needed, try to embed it in familiar context and provide mnemonic help wherever possible.
Being expressive also means focussing on how the programmer thinks and what meets there needs. The needs of the programmer are primary, the needs for the compiler are secondary. Often it is easier to understand a program when the constructs it uses are easy to compile – as there is less guesswork for the programmer to understand what is really going on. So the needs of the compiler often do not conflict with the needs of the programmer. When they do it is probably a sign of poor language design which should be addressed. If no means can be found to improve the design to it suits programmer and compiler, then the needs of the programmer must come first.
A key element of simple design is uniformity. If various features a provided uniformly then the programmer will not be forced to squeeze their design into a mismatched mould in order to use some feature – the feature will be available wherever it is needed. The most obvious consequence of this is that built-in types should not have access to any functionality that user-defined types do not have access to. It should be possible to implement any built-in type in the language rather than having to have it known directly to the compiler.
The are probably limits to this. “Boolean” is such a fundamental type that some aspects of it might need to be baked in to the language. However wherever that sort of dependency can be reasonably avoided, it should be.
The second gaol is preventing mistakes, and there are many aspects to this too. Mistakes can be simple typos, forgotten steps, or deep misunderstanding of the design and implementation. Preventing all of these is impossible. Preventing some of them is easy. Maximising the number of preventable errors without unduly restricting expressiveness is the challenge.
An important part of reducing errors is making the code easy to read. In any writing, the practice of writing a first draft and then reviewing and improving it is common. This is (or should be) equally true for writing a computer program. So when reading the program, the nature and purpose of the algorithm and data should stand out. The compiler should be able to detect and reject anything that might look confusing or misleading. When reading code that the compile accepts, it should be easy to follow and understand.
This leads to rules like “Different things should look different” and “similar things should look the same”. The latter is hopefully obvious and common. The former could benefit from some explanation.
There seems to be a tendency among programmerx and mathematician to find simple models that effective cover a wide range of cases. In mathematics, group theory is a perfect example. Many many different mathematical structures can be described as “groups”. This is very useful for drawing parallels and for understanding relationships and deep structure. However when it is carried across from mathematics to language design it does not work out so well.
For me, the main take away from my article – linked above – “Go and Rust – objects without class”, is that “everything is an object” and the implied “inheritance is all you need” is a bad idea. It blends together different concepts it a way that is ultimately unhelpful. When a programmer reads code and sees inheritance being used it may not be clear which of the several possible uses of inheritance is paramount. Worse: when a programmer creates a design they might use inheritance and not have a clear idea of exactly “why” they are using it. This can lead to muddy thinking and muddy code.
So: if things are different, they should look different. Occam’s razor suggests that “entities must not be multiplied beyond necessity”. This is valuable guidance, but leaves open the interpretation of “necessity”. I believe that in a programming language it is necessary to have sufficient entities that different terminology may be used to express different concepts. This ensures that the reader need not be left in doubt as to what is intended.
Finally, good error prevention requires even greater richness of abstractions than clarity of expression requires. For the language/compiler to be able to catch errors, it must have some degree of understanding as to what is going on. This requires that the programmer be able to describe at a rich level what is intended. And this requires rich concepts. It also requires complete coverage. If a programmer uses clear abstractions most of the time and drops into less clear expression occasionally, then it doesn’t greatly harm the ability of another programmer to read the code – they just need to concentrate a bit more on the vague bits. However that does make it a lot harder for the compiler to check. Those lapses from clarity, brief though they may be, are the most important parts to check.
Unfortunately complete coverage isn’t really a possibility. That was one of the points in my “A Taste of Rust” article. It unrealistic to expect any formal language to be very expressive and still completely safe. That isn’t an excuse not to try though. While the language cannot be expected to “understand” everything, careful choices of rich abstraction should be able to cover many common cases. There will still need to be times when the programmer escapes from strict language control and does “unsafe” things. These need to be carefully documented, and need to be able to “tell” the language what they have done, so the language can still check the way that these “unsafe” features are used. This refers back to the previous point about built-in types not being special and all features being available to user-defined types. In the same way, safety features need to be available in such a way that the programmer can make safety assertions about unsafe code.
As the language design progresses, each decision will need to be measured against these two key principles:
• Does it aid clarity of expressions?
• Does it help minimise errors?
These encompass many things so extra guidance will help. So far we have collected:
• Are the abstractions clear and useful?
• Are we using familiar constructs as much as possible?
• Have we thoroughly and convincingly defended any novelty?
• Does this benefit the programmer rather than the compiler?
• Is this design uniform? Can the idea apply everywhere? Can we make it apply anywhere else?
• Can this feature be used equally well be user-defined types and functions?
• Does this enhance readability? Can the language enforce anything to make this more readable when correct?
• Are we ensuring that similar things look similar?
• Are there different aspects to this that should look different?
• Can we help the compiler ‘understand’ what is going on in this construct?
• Is this “safety check” feature directly available for the programmer to assert in “unsafe” code.
Not all of these guides will apply to each decision, but some will. And the two over-riding principles really must be considered at every step.
So there is my philosophy. I have some idea where it leads, but I fully expect that as I try to justify my design against the philosophy I’ll be surprised occasionally. For you my dear reader I’m afraid you’ll have to wait a little while until next instalment. Maybe a week or so.
Posted in Language Design | Leave a comment
RAID – not just smoke and mirrors
My final talk at Linux.conf.au 2013 was about “md” software RAID.
Slides are here and video is here (mp4).
One take away, mainly from conversations afterwards, is that – there is a perception that – it is not that uncommon for drives to fail in a way that causes them to return the wrong data without error. Thus using checksum per block, or 3-drive RAID1 with voting, or RAID6 with P/Q checks on every read might actually be a good idea. It is sad that such drives are not extremely uncommon, but it seems that it might be a reality.
What does one do when one finds such a drive? Fixing the “error” and continuing quietly seems like a mistake. Kicking the drive from the array is probably right, but might be too harsh. Stopping all IO and waiting for operator assistance is tempting…. but crazy.
I wonder…
Posted in Uncategorized | Leave a comment
Wiggles and Diffs at LCA
My second talk at LCA2013 – the first one accepted – was on “wiggle”, my tool for applying patches that don’t apply. In the presentation I wanted to explain how “diff” works – as I then wanted to explain why one of the things that wiggle does is more complex that a simple “diff”. For this I came up with a simple animation that I presented as a series of “impress” slides. Some suggested I make them into an animated “gif”, so I did. And here it is (click for a higher-res version):
Animation of Diff algorithm
See slides for explanation
Among the useful feedback I got about wiggle:
• UTF-8 support would be good. This only applies to the way it breaks strings into words. Currently it only understand ASCII
• Detecting patterns of “replace A with B” and looking for unreplaced copies of “A” in the original might be useful.
The slides in LibreOffice format are here and the recording of the talk is here
Posted in Uncategorized | 1 Comment
Linux.conf.au – one down, two to go.
At linux.conf.au this week and as always it is proving to be a great conference. Bdale’s keynote on Monday was a really good opening keynote: very wide-ranging, very high level, very interesting and relevant, very pragmatic and sensible.
One of this key points was that we should all just keep building the tools we want to use and making it easy for others to contribute. The long tail of developers who submit just one patch to the Linux kernel make a significant contribution but wouldn’t be there if it was hard to contribute, hard to get the source, or hard to build the source. With Linux all of these are relatively easy and other projects could learn from that … particularly the “easy to build” bit.
So let’s not worry about beating MS or Apple, or about claiming the year of the Linux anything. Let’s just do stuff we enjoy and make stuff we use and share our enthusiasm with others. If that doesn’t lead to world domination, nothing will.
For myself, I managed to get 3 speaking slots this year … makes up for not speaking for some years I guess. My first was yesterday about the OpenPhoenux project – follow-on from OpenMoko. It was very well attended, I got really good responses and positive feedback. I even managed to finish very very nearly on time. So overall, quite a success. I hope the next two (both tomorrow, Wednesday) go as well.
You can view the slides if you like, but they aren’t as good without all the talking. Hopefully the LCA organisers will upload the video at some stage.
Posted in Uncategorized | Leave a comment
|
__label__pos
| 0.567175 |
Question: The results of a national survey showed that on average
The results of a national survey showed that on average, adults sleep 6.9 hours per night.
Suppose that the standard deviation is 1.2 hours and that the number of hours of sleep follows a bell-shaped distribution.
a. Use the empirical rule to calculate the percentage of individuals who sleep between 4.5 and 9.3 hours per day.
b. What is the z-value for an adult who sleeps 8 hours per night?
c. What is the z-value for an adult who sleeps 6 hours per night?
View Solution:
Sale on SolutionInn
Sales1
Views68
Comments
• CreatedNovember 21, 2015
• Files Included
Post your question
5000
|
__label__pos
| 0.991547 |
Source code for kedro.config.templated_config
# Copyright 2020 QuantumBlack Visual Analytics Limited
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# 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 WILL THE LICENSOR OR OTHER CONTRIBUTORS
# 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.
#
# The QuantumBlack Visual Analytics Limited ("QuantumBlack") name and logo
# (either separately or in combination, "QuantumBlack Trademarks") are
# trademarks of QuantumBlack. The License does not grant you any right or
# license to the QuantumBlack Trademarks. You may not use the QuantumBlack
# Trademarks or any confusingly similar mark as a trademark for your product,
# or use the QuantumBlack Trademarks in any other manner that might cause
# confusion in the marketplace, including but not limited to in advertising,
# on websites, or on software.
#
# See the License for the specific language governing permissions and
# limitations under the License.
"""This module provides ``kedro.config`` with the functionality to load one
or more configuration files from specified paths, and format template strings
with the values from the passed dictionary.
"""
import re
from copy import deepcopy
from typing import Any, Dict, Iterable, Optional, Union
import jmespath
from kedro.config.config import ConfigLoader
IDENTIFIER_PATTERN = re.compile(
r"""\$\{
(?P<path>[A-Za-z0-9_\.]+) # identifier
(?:\|(?P<default>[^}]*))? # optional default value
\}""",
re.VERBOSE,
)
FULL_STRING_IDENTIFIER_PATTERN = re.compile(
r"^" + IDENTIFIER_PATTERN.pattern + r"$", re.VERBOSE
)
[docs]class TemplatedConfigLoader(ConfigLoader): """ Extension of the ``ConfigLoader`` class that allows for template values, wrapped in brackets like: ${...}, to be automatically formatted based on the configs. The easiest way to use this class is by incorporating it into the ``KedroContext``. This can be done by extending the ``KedroContext`` and overwriting the config_loader method, making it return a ``TemplatedConfigLoader`` object instead of a ``ConfigLoader`` object. For this method to work, the context_path variable in `.kedro.yml` needs to be pointing at this newly created class. The `run.py` script has an extension of the ``KedroContext`` by default, called the ``ProjectContext``. Example: :: >>> from kedro.framework.context import KedroContext, load_context >>> from kedro.config import TemplatedConfigLoader >>> >>> >>> class MyNewContext(KedroContext): >>> >>> def _create_config_loader(self, conf_paths: Iterable[str]) -> TemplatedConfigLoader: >>> return TemplatedConfigLoader( >>> conf_paths, >>> globals_pattern="*globals.yml", >>> globals_dict={"param1": "pandas.CSVDataSet"} >>> ) >>> >>> my_context = load_context(Path.cwd(), env=env) >>> my_context.run(tags, runner, node_names, from_nodes, to_nodes) The contents of the dictionary resulting from the `globals_pattern` get merged with the ``globals_dict``. In case of conflicts, the keys in ``globals_dict`` take precedence. If the formatting key is missing from the dictionary, the default template value is used (the format is "${key|default value}"). If no default is set, a ``ValueError`` will be raised. Global parameters can be namespaced as well. An example could work as follows: `globals.yml` :: bucket: "my_s3_bucket" environment: "dev" datasets: csv: "pandas.CSVDataSet" spark: "spark.SparkDataSet" folders: raw: "01_raw" int: "02_intermediate" pri: "03_primary" fea: "04_feature" `catalog.yml` :: raw_boat_data: type: "${datasets.spark}" filepath: "s3a://${bucket}/${environment}/${folders.raw}/boats.csv" file_format: parquet raw_car_data: type: "${datasets.csv}" filepath: "s3://${bucket}/data/${environment}/${folders.raw}/cars.csv" This uses ``jmespath`` in the background. For more information see: https://github.com/jmespath/jmespath.py and http://jmespath.org/. """
[docs] def __init__( self, conf_paths: Union[str, Iterable[str]], *, globals_pattern: Optional[str] = None, globals_dict: Optional[Dict[str, Any]] = None ): """Instantiate a ``TemplatedConfigLoader``. Args: conf_paths: Non-empty path or list of paths to configuration directories. globals_pattern: Optional keyword-only argument specifying a glob pattern. Files that match the pattern will be loaded as a formatting dictionary. globals_dict: Optional keyword-only argument specifying a formatting dictionary. This dictionary will get merged with the globals dictionary obtained from the globals_pattern. In case of duplicate keys, the ``globals_dict`` keys take precedence. """ super().__init__(conf_paths) self._arg_dict = super().get(globals_pattern) if globals_pattern else {} globals_dict = deepcopy(globals_dict) or {} self._arg_dict = {**self._arg_dict, **globals_dict}
[docs] def get(self, *patterns: str) -> Dict[str, Any]: """Tries to resolve the template variables in the config dictionary provided by the ``ConfigLoader`` (super class) ``get`` method using the dictionary of replacement values obtained in the ``__init__`` method. Args: patterns: Glob patterns to match. Files, which names match any of the specified patterns, will be processed. Returns: A Python dictionary with the combined configuration from all configuration files. **Note:** any keys that start with `_` will be ignored. String values wrapped in `${...}` will be replaced with the result of the corresponding JMESpath expression evaluated against globals (see `__init` for more configuration files. **Note:** any keys that start with `_` details). Raises: ValueError: malformed config found. """ config_raw = super().get(*patterns) if self._arg_dict: return _format_object(config_raw, self._arg_dict) return config_raw
def _format_object(val: Any, format_dict: Dict[str, Any]) -> Any: """Recursive function that loops through the values of a map. In case another map or a list is encountered, it calls itself. When a string is encountered, it will use the `format_dict` to replace strings that look like `${expr}`, where `expr` is a JMESPath expression evaluated against `format_dict`. Some notes on behavior: * If val is not a dict, list or string, the same value gets passed back. * If val is a string and does not match the ${...} pattern, the same value gets passed back. * If the value inside ${...} does not match any keys in the dictionary, the error is raised, unless a default is provided. * If the default is provided with ${...|default}, and the key is not found in the dictionary, the default value gets passed back. * If the ${...} is part of a larger string, the corresponding entry in the `format_dict` gets parsed into a string and put into the larger string. Examples: val = "${test_key}" with format_dict = {'test_key': 'test_val'} returns 'test_val' val = 5 (i.e. not a dict, list or string) returns 5 val = "test_key" (i.e. does not match ${...} pattern returns 'test_key' (irrespective of `format_dict`) val = "${wrong_test_key}" with format_dict = {'test_key': 'test_val'} raises ``ValueError`` val = "string-with-${test_key}" with format_dict = {'test_key': 1000} returns "string-with-1000" val = "${wrong_test_key|default_value}" with format_dict = {} returns 'default_value' Args: val: If this is a string of the format `${expr}`, it gets replaced by the result of JMESPath expression format_dict: A lookup from string to string with replacement values Returns: A string formatted according to the ``format_dict`` input. Raises: ValueError: The input data is malformed. """ def _format_string(match): value = jmespath.search(match.group("path"), format_dict) if value is None: if match.group("default") is None: raise ValueError( "Failed to format pattern '{}': " "no config value found, no default provided".format(match.group(0)) ) return match.group("default") return value if isinstance(val, dict): new_dict = {} for key, value in val.items(): if isinstance(key, str): formatted_key = _format_object(key, format_dict) if not isinstance(formatted_key, str): raise ValueError( "When formatting '{}' key, only string values can be used. " "'{}' found".format(key, formatted_key) ) key = formatted_key new_dict[key] = _format_object(value, format_dict) return new_dict if isinstance(val, list): return [_format_object(e, format_dict) for e in val] if isinstance(val, str): # Distinguish case where entire string matches the pattern, # as the replacement can be of a different type match_full = FULL_STRING_IDENTIFIER_PATTERN.match(val) if match_full: return _format_string(match_full) return IDENTIFIER_PATTERN.sub(lambda m: str(_format_string(m)), val) return val
|
__label__pos
| 0.991199 |
Introducing Resource Awareness to SR Segments Huawei Technologies
[email protected]
KDDI Corporation
[email protected]
China Telecom
[email protected]
China Mobile
[email protected]
China Mobile
[email protected]
SPRING Working Group This document describes the mechanism to associate network resources to Segment Routing Identifiers (SIDs). Such SIDs are referred to as resource-aware SIDs in this document. The resource-aware SIDs retain their original forwarding semantics, but with the additional semantics to identify the set of network resources available for the packet processing and forwarding action. The resource-aware SIDs can therefore be used to build SR paths or virtual networks with a set of reserved network resources. The proposed mechanism is applicable to both segment routing with MPLS data plane (SR-MPLS) and segment routing with IPv6 data plane (SRv6).
Segment Routing (SR) specifies a mechanism to steer packets through an ordered list of segments. A segment is referred to by its Segment Identifier (SID). With SR, explicit source routing can be achieved without introducing per-path state into the network. Compared with RSVP-TE , the base SR specifications do not have the capability of reserving network resources or identifying a set of network resources reserved for an individual or a group of services or customers. Although a centralized controller can have a global view of network state and can provision different services using different SR paths, in data packet forwarding it still relies on the DiffServ QoS mechanism to provide coarse-grained traffic differentiation in the network. While such a mechanism may be sufficient for some types of services, some customers or services may require to have a set of dedicated network resources allocated in the network to achieve resource isolation from other customers/services in the same network. Also note the number of such customers or services could be larger than the number of traffic classes available with DiffServ QoS. Without needing to define new SID types, this document extends the SR paradigm by associating SIDs with network resource attributes. These resource-aware SIDs retain their original functionality, with the additional semantics of identifying the set of network resources available for the packet processing action. Typical types of network resources include link bandwidth, buffers, and queues that are associated with class of service, scheduling weights or time cycles, and it is also possible to associate SR SIDs with other types of resources (e.g., the processing and storage resources). On a particular segment, multiple resource-aware SIDs can be allocated, each of which represents a subset of network resources allocated in the network to meet the requirements of an individual or a group of customers or services. The allocation of network resources on segments can be done either via local configuration or via a centralized controller. Other approaches are possible such as use of a control plane signaling protocol, but they are out of the scope of this document. Each set of network resources can be associated with one or multiple resource-aware SIDs. The resource-aware SIDs can be used to build SR paths with a set of reserved network resources, which can be used to carry service traffic which requires dedicated network resources along the path. The resource-aware SIDs can also be used to build SR-based virtual networks with the required network topology and resource attributes. The mechanism is applicable to SR with both MPLS data plane (SR-MPLS) and IPv6 data plane (SRv6).
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP14 when, and only when, they appear in all capitals, as shown here.
In Segment Routing architecture , several types of segments are defined to represent either topological or service instructions. A topological segment can be a node segment or an adjacency segment. A service segment may be associated with specific service functions for service chaining purpose. This document introduces additional resource semantics to these existing types of SIDs, so that the resource-aware SIDs can be used to identify not only the topology or service functions, but also the set of network resources allocated on the segments for packet processing. This section describes the mechanisms of using SR SIDs to identify the additional resource information associated with the SR paths or virtual networks based on the two SR data plane instantiations: SR-MPLS and SRv6. The mechanisms to identify the forwarding path or network topology with SIDs as defined in can be reused, and the control plane can be based on , and .
The MPLS instantiation of Segment Routing is specified in . As specified in , an IGP Adjacency Segment (Adj-SID) is an SR segment attached to a unidirectional adjacency or a set of unidirectional adjacencies. An IGP Prefix Segment (Prefix-SID) is an SR segment attached to an IGP prefix, which identifies an instruction to forward the packet along the path computed using the routing algorithm in the associated topology. An IGP node segment is an IGP-Prefix segment that identifies a specific router (e.g., a loopback). As described in and , a BGP PeerAdj SID is used as an instruction to steer over a local interface towards a specific peer node in a peering Autonomous System (AS). These types of SID can be extended to represent both the topological instructions and the set of network resources allocated for packet processing following the instruction. A resource-aware Adj-SID represents a subset of the resources (e.g., bandwidth, buffer and queuing resources) of a given link, thus each resource-aware Adj-SID is associated with a subset of the link's traffic engineering (TE) capabilities and resources (known as TE attributes ). For one IGP link, multiple resource-aware Adj-SIDs can be allocated, each of which is associated with a subset of the link resources allocated on the link. For one inter-domain link, multiple BGP PeerAdj SIDs may be allocated, each of which is associated with a subset of the link resources allocated on the inter-domain link. The resource-aware Adj-SIDs may be associated with a specific network topology and/or algorithm, so that it is used only for resource-aware SR paths computed within the topology and/or algorithm. Note this per-segment resource allocation complies with the SR paradigm, which avoids introducing per-path state into the network. Several approaches can be used to partition and reserve the link resources, such as , logical sub-interfaces, dedicated queues, etc. The detailed mechanism of link resource partitioning is out of scope of this document. A resource-aware prefix-SID is associated with a network topology and/or algorithm in which the attached node participates, and in addition, a resource-aware prefix-SID is associated with a set of network resources (e.g., bandwidth, buffer and queuing resources) allocated on each node and link participating in the same topology and/or algorithm. Such set of network resources can be used for forwarding packets which are encapsulated with this resource-aware prefix-SID along the paths computed in the associated topology and/or algorithm. Although it is possible that each resource-aware prefix-SID is associated with a set of dedicated resources in the network, this implies the overhead with per-prefix resource reservation in both control plane signaling and data plane states, and if network resources are allocated for one prefix on all the possible paths, it is likely some resources will be wasted. A practical approach is that a common set of network resources are allocated by each network node and link participating in a topology and/or algorithm, and are associated with a group of resource-aware prefix-SIDs of the same topology and/or algorithm. Such common set of network resources constitutes a network resource group. For a given <topology, algorithm> tuple, there can be one or multiple network resource groups, the resource-aware prefix-SIDs which are associated with the same <topology, algorithm> tuple share the path computation result. This helps to reduce the dynamics in per-prefix resource allocation and adjustment, so that the network resource can be allocated based on planning and does not have to rely on dynamic signaling. When the set of nodes and links participate in a <topology, algorithm> tuple changes, the set of network resources allocated on specific nodes and links may need to be adjusted. This means that the resources allocated to resource-aware Adj-SIDs on those links may have to be adjusted and new TE attributes for the associated adj-SIDs re-advertised. For one IGP prefix, multiple resource-aware prefix-SIDs can be allocated. Each resource-aware prefix-SID may be associated with a unique <topology, algorithm> tuple, in this case different <topology, algorithm> tuples can be used to distinguish the resource-aware prefix-SIDs of the same prefix. In another case, for one IGP prefix, multiple resource-aware prefix-SIDs may be associated with the same <topology, algorithm> tuple, then an additional control plane distinguisher needs to be introduced to distinguish different resource-aware prefix-SIDs associated with the same <topology, algorithm> but different groups of network resources. A group of resource-aware Adj-SID and resource-aware Prefix-SIDs can be used to construct the SID lists, which are used to steer the traffic to be forwarded along the explicit paths (either strict or loose) and processed using the set of network resources identified by the resource-aware SIDs. In data packet forwarding, each resource-aware adj-SID identifies both the next-hop and the set of resources used for packet processing on the outgoing interface. Each resource-aware Prefix-SID identifies the path to the node which the prefix is attached to, and the common set of network resources used for packet forwarding on network nodes along the path. The transit nodes use the resource-aware prefix-SIDs to determine the next-hop of the packet and the set of associated local resources, then forward the packet to the next-hop using the set of local resources. When the set of network resources allocated on the egress node also needs to be determined, it is RECOMMENDED that Penultimate Hop Popping (PHP) be disabled, otherwise the inner service label needs to be used to infer the set of resources to be used for packet processing on the egress node of the SR path. This mechanism requires the allocation of additional prefix-SIDs or adj-SIDs for network segments to identify different sets of network resources. As the number of resource groups increases, the number of SIDs would increase accordingly, while it should be noted that there is still no per-path state introduced into the network.
As specified in , an SRv6 Segment Identifier (SID) is a 128-bit value which consists of a locator (LOC) and a function (FUNCT), optionally it may also contain additional arguments (ARG) immediately after the FUNCT. The Locator part of the SID is routable and leads to the node which instantiates that SID, which means the Locator can be parsed by all nodes in the network. The FUNCT part of the SID is an opaque identification of a local function bound to the SID, and the ARG part of the SID can be used to encode additional information for the processing of the behavior bound to the SID. Thus the FUNCT and ARG parts can only be parsed by the node which instantiates the SRv6 SID. For one SRv6 node, multiple resource-aware SRv6 Locators can be allocated. A resource-aware Locator is associated with a network topology and/or algorithm in which the node participates, and in addition, a resource-aware Locator is associated with a set of local resources (e.g., bandwidth, buffer, and queueing resources) on each node participating in the same topology and/or algorithm. Such a set of network resources are used to forward the packets with SIDs which have the resource-aware Locator as its prefix, along the path computed with the associated topology and/or algorithm. Similar to the resource-aware prefix-SIDs in SR-MPLS, a practical approach is that a common set of network resources are allocated by each network node and link participating in a topology and/or algorithm, and are associated with a group of resource-aware Locators of the same topology and/or algorithm. For one IGP link, multiple resource-aware SRv6 End.X SIDs can be allocated to identify different set of link resources. Each resource-aware End.X SID SHOULD use a resource-aware locator as its prefix. SRv6 SIDs for other types of functions MAY also be assigned as resource-aware SIDs, which can identify the set of network resources allocated by the node for executing the behavior. A group of resource-aware SRv6 SIDs can be used to construct the SID lists, which are used to steer the traffic to be forwarded along the explicit paths (either strict or loose) and processed using the set of network resources identified by the resource-aware SIDs and Locators. In data packet forwarding, each resource-aware End.X SID identifies both the next-hop and the set of resources used for packet processing on the outgoing interface. Each resource-aware Locator identifies the path to the node which the Locator is assigned to, and the set of network resources used for packet forwarding on network nodes along the path. The transit nodes use the resource-aware Locators to determine the next-hop of the packet and the set of associated local resources, then forward the packet to the next-hop using the set of local resources. This mechanism requires the allocation of additional SRv6 Locators and SIDs for network segments to identify different set of network resources. As the number of resource groups increases, the number of SRv6 Locators and SIDs would increase accordingly, while it should be noted that there is still no per-path state introduced into the network.
The mechanism described in this document makes use of a centralized controller to collect the information about the network (configuration, state, routing databases, etc.) as well as the service information (traffic matrix, performance statistics, etc.) for the planning of network resources based on the service requirement. Then the centralized controller instructs the network nodes to allocate the network resources and associate the resources with the resource-aware SIDs. The resource-aware SIDs can be either explicitly provisioned by the controller, or dynamically allocated by network nodes then reported to the controller. The controller is also responsible for the centralized computation and optimization of the SR paths taking the topology, algorithm and network resource constraints into consideration. The interaction between the controller and the network nodes can be based on Netconf/YANG , BGP-LS , BGP SR Policy or PCEP . In some scenarios, extensions to some of these protocols are needed, which are out of the scope of this document. In some cases, a centralized controller may not be used, but this would complicate the operations and planning therefore is not suggested. On network nodes, the support for a resource group and the information to associate packets with that resource group needs to be advertised in the control plane, so that all the nodes have a consistent view of the resource group. Given that resource management is a central function, the knowledge of the exact resources provided to a resource group needs to be known accurately by the relevant central control components (e.g., PCE) and the network nodes. This may be done by configuration, alternative protocols, or by advertisements in the IGP for collection by BGP-LS. If there are related link advertisements, then consistency MUST be assured across that set of advertisements. The distributed control plane is complementary to the centralized controller. A distributed control plane can be used for the collection and distribution of the network topology and resource information associated with the resource-aware SIDs among network nodes, then some of the nodes can distribute the collected information to the centralized controller. To advertise the support for a given resource group, a node needs to advertise the identifier of the resource group, the associated topology and algorithm, the resource-aware SIDs and potentially a set of TE attributes representing the resources allocated to it. Distributed route computation with topology, algorithm and/or resource constraints may also be performed by network nodes. The distributed control plane may be based on , , with necessary extensions. When a network node is instructed to associate a SID with specific resources, its actions will depend on the operational configuration of the network. In some cases the association between SIDs and resources is configured on the individual network nodes, and the control plane (e.g. IGP) is used to distribute the SID information and resource availability to the controller and the ingress nodes for TE constraint-based path computation. In hybrid cases with SR and other TE mechanisms co-existing in the network, the IGP advertisements of available resources may need to be updated to indicate that there has been a change to the available resources resulting from the instantiation of a new resource-aware SID: such updates would be rate-limited in the normal way. In still other cases the association between SIDs and network resources is known by the central controller which is responsible for all TE management, the distributed control plane does not need to take any additional action.
This document makes no request of IANA. Note to RFC Editor: this section may be removed on publication as an RFC.
The security considerations of segment routing in are applicable to this document. The resource-aware SIDs may be used for provisioning of SR paths or virtual networks to carry traffic with specific SLA requirement (such as latency). By disrupting the SLA of such traffic an attack can be directly targeted at the customer application, or can be targeted at the network operator by causing them to violate their SLA, triggering commercial consequences. Dynamic attacks of this sort are not something that networks have traditionally guarded against, and networking techniques need to be developed to defend against this type of attack. By rigorously policing ingress traffic and carefully provisioning network resources provided to such services, this type of attack can be prevented. However care needs to be taken when providing shared resources, and when the network needs to be reconfigured as part of ongoing maintenance or in response to a failure. The details of the underlay network MUST NOT be exposed to third parties, to prevent attacks aimed at exploiting shared network resources.
The authors would like to thank Mach Chen, Stefano Previdi, Charlie Perkins, Bruno Decraene, Loa Andersson, Alexander Vainshtein and John Drake for the valuable discussion and suggestions to this document.
Flex Ethernet Implementation Agreement
|
__label__pos
| 0.988007 |
1. WordPress Snippets
Increasing WordPress Memory Limit
If you work in WordPress and need a way to increase the memory limit in WordPress to can add more resources to WordPress, there are a few ways to do that and will explain one of this ways so all you need to add a PHP constant to the wp-config.php file.
WP_MEMORY_LIMIT is a PHP constant add to the WordPress option that allows you to specify the maximum amount of memory that can be consumed by PHP where sometimes you get an error like this:
Fatal error: allowed memory size of 157286400 bytes exhausted (tried to allocate 5775295 bytes)
This code snippet will let you enable or disable debug mode with simple steps
Steps to increase WordPress memory limit:
1. Open your host root public_html folder
2. Open the wp-config.php file with an integrated editor, if you work localhost opens the same file using any code editor IDE.
3. Simply add the following code
4. Save the changes and check your pages as the custom text will show in the single product page or archive pages.
define('WP_MEMORY_LIMIT', '256M');
Comments to: Increasing WordPress Memory Limit
Your email address will not be published. Required fields are marked *
|
__label__pos
| 0.503838 |
The command-line is the interactive interface to your shell.
learn more… | top users | synonyms (1)
7
votes
2answers
2k views
XFCE or pure X11 commands, toggle compositing immediately without restarting X
How can i disable compositing via the command line? I need to disable temporarily for some games, like Nexuiz, for use in a wrapper script to toggle compositing status.
5
votes
1answer
2k views
Git auto-complete
I am using Git as many of you do. Also, I don't use any GUI for that — just CLI. So I was wondering: are there any way to make Git commands (git status, git checkout etc.) complete themselves when ...
1
vote
0answers
79 views
Creating and updating the packages for many Debian systems
I'm using a Lenny (Debian 5) for remotely controlled PC's (around 100 PC's) which will be pinging to my apache server. I'm developing a patch twice in a week to keep updated with the latest versions ...
2
votes
2answers
967 views
What would it take to add a command to run a script at the completion any given random task?
I was playing around with Pushover, and had the thought that it would be cool if I could use it as an argument on any random command, so that it would run a pushover script at the end of the task, ...
3
votes
1answer
2k views
Switch to an application using its PID
I'm using Gnome. In vim, I want to map a key to switch to Firefox. I know that I should use bash commands (a command in form of !...). Is it possible to switch to an application using its PID?
3
votes
2answers
2k views
Is it possible to disable verbose in the middle of running?
I am running a program fls (from the Sleuth Kit) with option -v for verbose mode. However it takes too long, and the program is still running since yesterday. I guess it will run faster without ...
3
votes
2answers
8k views
Undo `mv` command? [duplicate]
Possible Duplicate: Moved bin and other folders! How to get them back? Hi I'm in desperate need of help. I'm quite new to linux so please bear with my stupidity! I entered the following ...
1
vote
1answer
2k views
When a command is over half the terminal size it breaks
Whenever I type in a bash command longer than about half the width of the shell window I'm in, the command breaks like it would if I filled the whole screen 3rd command in image - typed a few xs ...
2
votes
4answers
15k views
How to pause listing long text file with cat in command prompt after 10lines then press any key
How to pause listing long text file with cat in command prompt after 10lines then press any key. for example: cat myfiles.txt bla bla bla bla bla bla . . . bla press enter to continue
1
vote
1answer
495 views
Sun blade 2000 - no prompt
I just bought a Sun Blade 2000 and a type 7 USB keyboard from EBAY. The blade has Solaris 8 installed and while I can login, I'd rather switch to something like UBUNTU. If I type STOP - A during the ...
17
votes
8answers
37k views
What's the quickest way to add text to a file from the command line?
Occasionally I have a thought that I want to write into a file while I am at the terminal. I would want these notes all in the same file, just listed one after the other. I would also like a date / ...
5
votes
1answer
558 views
How to make sure OpenVPN is connected?
I need some sort of "safeguard" for my VPN connection. If the connection drops, the machine shouldn't even reach the internet. (I can reach the machine by other means.) Is it possible somehow? If I ...
11
votes
1answer
10k views
Meaning of root:wheel
What does root:wheel mean in the following? chown root:wheel myfile
4
votes
4answers
1k views
Replace whole line in a file from command-line
I have a text file which has some contents similar to this: # General information about the project. project = u'Py6S' copyright = u'2012, Robin Wilson' # The version info for the project you're ...
3
votes
1answer
730 views
Live program output monitoring tool
I would like to know if there is a tool that would enable you to watch how the program output changes live. Something like tail -f but instead of monitoring the file changes, it would repeatedly call ...
22
votes
11answers
98k views
List of useful `less` functions
Rather than ask for your favorite, lets just list them off. What are the more useful commands inside less? Personally, I use: / (search forward) ? (search backwards) F (enable tail -f like ...
0
votes
1answer
100 views
Why does this compound command report errors when copying directories? [duplicate]
Possible Duplicate: Why does this compound command report errors when copying directories? if one executes the following two commands in one line, as follows, rm -rf dir ; cp -r dir2 dir ...
2
votes
5answers
1k views
Where are command line arguments (e.g. 'some.text') actually passed to?
From what I know, parameters you pass to a command, goes to it's STDIN stream. so this: cut -d. -f2 'some.text' should be perfectly identical to this: echo 'some.text' | cut -d. -f2 as we send ...
2
votes
2answers
980 views
Inner function call with xargs parameters
I am trying to create a file occurent within my /tmp directory of each file containing a speicific string. The problem is that the call to basename {} does not seem to work. Neither this, neither ...
23
votes
1answer
2k views
Is there a standard command that always exits with a failure?
I want to test my script with a command that fails. I could use an existing command with bad arguments. I could also write a simple script that immediately exits with a failure. Both of these are easy ...
8
votes
3answers
2k views
Where to start creating CLI applications? [closed]
After using linux for a month or two, I know what I'm doing now. When creating programs, using whatever language, I've obviously been using code like this: $ python test.py And so if I wanted test....
3
votes
2answers
389 views
Any CLI to validate URL? [closed]
I got a bunch of URLs (more than 1,000) and I am wondering if there is any CLI script to validate URL for http schema?
10
votes
4answers
1k views
How do I shutdown, reboot and logout the system from the command-line?
I would like to do that using the command-line, because sometimes my computer freezes and I need to force a shutdown (I know it's not good to the hardware). And: What is the difference between Halt ...
22
votes
4answers
1k views
Are Linux utilities smart when running piped commands?
I was just running a few commands in a terminal and I started wondering, does Unix/Linux take shortcuts when running piped commands? For example, let's say I have a file with one million lines, the ...
3
votes
1answer
2k views
How to do df only on root partition?
How can get df results only for / partition. The partition name/identification (/dev/sda2, /dev/cciss/c0d0p1) could vary on different computers.
5
votes
1answer
534 views
Is there an operator like && that ignores return status?
I've discovered the following useful trick for long-running tasks on the command line: do_some_task && make_a_noise For instance, on OSX: do_some_task && say 'done' However, &...
4
votes
1answer
926 views
How to run this in sudo?
I have this line that I execute from php sudo -u db2inst1 -s -- "/opt/ibm/db2/current/bin/db2 connect to PLC; /opt/ibm/db2/current/bin/db2 \"update EDU.contact set MOBILE_PHONE = '123'\"" it works ...
1
vote
1answer
4k views
Check if the command exists in bash [duplicate]
I want to check if a given command exists in bash and I care only about the native commands of the bash and not the scripts written by the user. When I refer to native commands I mean all those ...
-1
votes
3answers
408 views
Duplicate bash prompts
I'm having an interesting issue with XFCE Terminal/Gnome Terminal (not reproducible in XTerm), where executing bash or logging in using login or su will open a new Bash instance inside a Bash instance ...
3
votes
0answers
99 views
Importing hdhomerun channels into MythTV
I am setting up a MythTV backend, to stream Live TV from. I scanned for channels with the hdhomerun_config utility, and got this However, I really don't have a clue how to import it into MythTV.
2
votes
2answers
2k views
random number needed
I need a command line script that will generate a random integer between 1 and 6. I'm using Ubuntu with bash. I was working on this a couple of months ago using 'bc', but never got it to work ...
2
votes
1answer
102 views
How to make a module dynamically loadable on Debian?
I'm applying an API from maxmind. They require additional an module for Apache. Now they recommend the command: apxs -i -a -L/usr/local/lib -I/usr/local/include -lGeoIP -c mod_geoip.c -I/usr/local/...
11
votes
5answers
2k views
Is there a good combination of command-line and graphical file browser?
Is there a feasible solution than combines the advantages of a command-line and a graphical file browser? For example, the command-line is good to change the directory and execute commands but can't ...
19
votes
6answers
907 views
How stable are Unix shell “stdin/stdout APIs”?
grepping, awking, sedding, and piping are day-to-day routine of a user of any Unix-like operating system, may it be on the command line or inside a shell script (collectively called filters from now ...
17
votes
2answers
528 views
Is there a standard Unix command to check English verb conjugation?
Having recently come across wordlist and wordnet, two great discoveries on their own, I'm now looking for a similar tool, if simpler, that will take the bare infinitive of a verb and return the simple ...
1
vote
1answer
275 views
How to configure a shortcut to open a window accessed by right click on the systray icon?
The application I am referring to is Turpial and it is a Twitter client. The problem is to open the window I need to send twits, I have to right click on a systray icon and select an option. In the ...
1
vote
1answer
458 views
How to create a cron which finds/kills/clears old puppet runs?
I am a new user of bash/cron, and I was given a task to create a cron which finds/kill/ and clears old puppet runs that were not successfully installed. The more help the better, but I am more or less ...
6
votes
4answers
2k views
Is there a difference between these two commands?
cat a > b and cp a b If they are functionally the same for all intents and purposes, which one is faster?
2
votes
0answers
35 views
Batch up a number of jobs to run concurrently [duplicate]
Possible Duplicate: Four tasks in parallel… how do I do that? I have a group of jobs to run (a few hundred jobs) - they have a variety of command names and parameters. Each one runs ...
5
votes
1answer
1k views
Redirect terminal output to image file
I need to programmatically run some unix commands and get the output in a image file, the format could be png or jpeg (jpg). The commands are run in an AIX (IBM *nix) machine. I don't have ...
1
vote
2answers
479 views
Command-line web browser with Kerberos authentication?
QUESTION: Is there a Kerberos-friendly web browser usable via an SSH console? I have tried links but it does not seem to work with Kerberos (the webapp asks me for login/password even though I have a ...
3
votes
4answers
297 views
Change working directory of 2 terminals at once
I've typically have gnome-terminal open with ~8 tabs, using 2 consecutive tabs for the same task (one has emacs, the other is used to do git checkins and unittest runs and so). When changing tasks, I ...
7
votes
2answers
807 views
Shell Script for going through a dir recursively and chmodding based on conditions of file type
Can anyone point me to either code or a tutorial for writing a shell script that can recursively go through an entire directory structure (starting at the current working directory, or given an ...
1
vote
2answers
874 views
Search and delete .Trash
I have 4 large USB devices with lots of backups collected over the years. I want to search for all .Trash folders and delete the contents on Fedora 17. I tried the following which failed:- # ...
2
votes
1answer
607 views
Creating a list of unique senders from Thunderbird mail files through the command-line
I've got some large mailboxes and using Thunderbird, that means that I have several mbox files. These single files contain all e-mails in a particular folder. Now, I would like to get some data on the ...
1
vote
1answer
139 views
attr man page missing?
How does one search for certain manpages (such as http://linux.die.net/man/5/attr)? Trying: man attr and man -K attr don't seem to work. Any ideas why?
0
votes
1answer
851 views
OSX : rmdir “permission denied” but directory removed
This is a question from a newbie trying to learn UNIX commands. I was trying to test the rmdir command by removing a test directory located in my Downloads directory. I have read and write rights on ...
11
votes
2answers
2k views
Where has the trailing newline char gone from my command substitution?
The following code best describes the situation. Why is the last line not outputting the trailing newline char? Each line's output is shown in the comment. I'm using GNU bash, version 4.1.5 ...
2
votes
2answers
357 views
CentOS 5.6 live time feature without repeatedly executing date command
I am using CentOS 5.6, is there a way to view a "live" time, without constantly executing the date command? Constantly excuting the date command can be quite frustrating and repetitive when checking ...
2
votes
2answers
1k views
what does Curl's stand-alone hyphen (-) mean?
what's the stand-alone hyphen (between the -C & -O) stand for in this command? curl -C - -O http://www.intersil.com/content/dam/Intersil/documents/fn67/fn6742.pdf FWIW- I'm following a ...
|
__label__pos
| 0.788844 |
blob: 4915efa551fca122434cc926adcf92721b58018f [file] [log] [blame]
/*
* Driver for audio on multifunction CS5535/6 companion device
* Copyright (C) Jaya Kumar
*
* Based on Jaroslav Kysela and Takashi Iwai's examples.
* This work was sponsored by CIS(M) Sdn Bhd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <asm/io.h>
#include <sound/core.h>
#include <sound/control.h>
#include <sound/pcm.h>
#include <sound/rawmidi.h>
#include <sound/ac97_codec.h>
#include <sound/initval.h>
#include <sound/asoundef.h>
#include "cs5535audio.h"
#define DRIVER_NAME "cs5535audio"
static char *ac97_quirk;
module_param(ac97_quirk, charp, 0444);
MODULE_PARM_DESC(ac97_quirk, "AC'97 board specific workarounds.");
static struct ac97_quirk ac97_quirks[] __devinitdata = {
#if 0 /* Not yet confirmed if all 5536 boards are HP only */
{
.subvendor = PCI_VENDOR_ID_AMD,
.subdevice = PCI_DEVICE_ID_AMD_CS5536_AUDIO,
.name = "AMD RDK",
.type = AC97_TUNE_HP_ONLY
},
#endif
{}
};
static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
module_param_array(index, int, NULL, 0444);
MODULE_PARM_DESC(index, "Index value for " DRIVER_NAME);
module_param_array(id, charp, NULL, 0444);
MODULE_PARM_DESC(id, "ID string for " DRIVER_NAME);
module_param_array(enable, bool, NULL, 0444);
MODULE_PARM_DESC(enable, "Enable " DRIVER_NAME);
static DEFINE_PCI_DEVICE_TABLE(snd_cs5535audio_ids) = {
{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_AUDIO) },
{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_AUDIO) },
{}
};
MODULE_DEVICE_TABLE(pci, snd_cs5535audio_ids);
static void wait_till_cmd_acked(struct cs5535audio *cs5535au, unsigned long timeout)
{
unsigned int tmp;
do {
tmp = cs_readl(cs5535au, ACC_CODEC_CNTL);
if (!(tmp & CMD_NEW))
break;
udelay(1);
} while (--timeout);
if (!timeout)
snd_printk(KERN_ERR "Failure writing to cs5535 codec\n");
}
static unsigned short snd_cs5535audio_codec_read(struct cs5535audio *cs5535au,
unsigned short reg)
{
unsigned int regdata;
unsigned int timeout;
unsigned int val;
regdata = ((unsigned int) reg) << 24;
regdata |= ACC_CODEC_CNTL_RD_CMD;
regdata |= CMD_NEW;
cs_writel(cs5535au, ACC_CODEC_CNTL, regdata);
wait_till_cmd_acked(cs5535au, 50);
timeout = 50;
do {
val = cs_readl(cs5535au, ACC_CODEC_STATUS);
if ((val & STS_NEW) && reg == (val >> 24))
break;
udelay(1);
} while (--timeout);
if (!timeout)
snd_printk(KERN_ERR "Failure reading codec reg 0x%x,"
"Last value=0x%x\n", reg, val);
return (unsigned short) val;
}
static void snd_cs5535audio_codec_write(struct cs5535audio *cs5535au,
unsigned short reg, unsigned short val)
{
unsigned int regdata;
regdata = ((unsigned int) reg) << 24;
regdata |= val;
regdata &= CMD_MASK;
regdata |= CMD_NEW;
regdata &= ACC_CODEC_CNTL_WR_CMD;
cs_writel(cs5535au, ACC_CODEC_CNTL, regdata);
wait_till_cmd_acked(cs5535au, 50);
}
static void snd_cs5535audio_ac97_codec_write(struct snd_ac97 *ac97,
unsigned short reg, unsigned short val)
{
struct cs5535audio *cs5535au = ac97->private_data;
snd_cs5535audio_codec_write(cs5535au, reg, val);
}
static unsigned short snd_cs5535audio_ac97_codec_read(struct snd_ac97 *ac97,
unsigned short reg)
{
struct cs5535audio *cs5535au = ac97->private_data;
return snd_cs5535audio_codec_read(cs5535au, reg);
}
static int __devinit snd_cs5535audio_mixer(struct cs5535audio *cs5535au)
{
struct snd_card *card = cs5535au->card;
struct snd_ac97_bus *pbus;
struct snd_ac97_template ac97;
int err;
static struct snd_ac97_bus_ops ops = {
.write = snd_cs5535audio_ac97_codec_write,
.read = snd_cs5535audio_ac97_codec_read,
};
if ((err = snd_ac97_bus(card, 0, &ops, NULL, &pbus)) < 0)
return err;
memset(&ac97, 0, sizeof(ac97));
ac97.scaps = AC97_SCAP_AUDIO | AC97_SCAP_SKIP_MODEM
| AC97_SCAP_POWER_SAVE;
ac97.private_data = cs5535au;
ac97.pci = cs5535au->pci;
/* set any OLPC-specific scaps */
olpc_prequirks(card, &ac97);
if ((err = snd_ac97_mixer(pbus, &ac97, &cs5535au->ac97)) < 0) {
snd_printk(KERN_ERR "mixer failed\n");
return err;
}
snd_ac97_tune_hardware(cs5535au->ac97, ac97_quirks, ac97_quirk);
err = olpc_quirks(card, cs5535au->ac97);
if (err < 0) {
snd_printk(KERN_ERR "olpc quirks failed\n");
return err;
}
return 0;
}
static void process_bm0_irq(struct cs5535audio *cs5535au)
{
u8 bm_stat;
spin_lock(&cs5535au->reg_lock);
bm_stat = cs_readb(cs5535au, ACC_BM0_STATUS);
spin_unlock(&cs5535au->reg_lock);
if (bm_stat & EOP) {
struct cs5535audio_dma *dma;
dma = cs5535au->playback_substream->runtime->private_data;
snd_pcm_period_elapsed(cs5535au->playback_substream);
} else {
snd_printk(KERN_ERR "unexpected bm0 irq src, bm_stat=%x\n",
bm_stat);
}
}
static void process_bm1_irq(struct cs5535audio *cs5535au)
{
u8 bm_stat;
spin_lock(&cs5535au->reg_lock);
bm_stat = cs_readb(cs5535au, ACC_BM1_STATUS);
spin_unlock(&cs5535au->reg_lock);
if (bm_stat & EOP) {
struct cs5535audio_dma *dma;
dma = cs5535au->capture_substream->runtime->private_data;
snd_pcm_period_elapsed(cs5535au->capture_substream);
}
}
static irqreturn_t snd_cs5535audio_interrupt(int irq, void *dev_id)
{
u16 acc_irq_stat;
unsigned char count;
struct cs5535audio *cs5535au = dev_id;
if (cs5535au == NULL)
return IRQ_NONE;
acc_irq_stat = cs_readw(cs5535au, ACC_IRQ_STATUS);
if (!acc_irq_stat)
return IRQ_NONE;
for (count = 0; count < 4; count++) {
if (acc_irq_stat & (1 << count)) {
switch (count) {
case IRQ_STS:
cs_readl(cs5535au, ACC_GPIO_STATUS);
break;
case WU_IRQ_STS:
cs_readl(cs5535au, ACC_GPIO_STATUS);
break;
case BM0_IRQ_STS:
process_bm0_irq(cs5535au);
break;
case BM1_IRQ_STS:
process_bm1_irq(cs5535au);
break;
default:
snd_printk(KERN_ERR "Unexpected irq src: "
"0x%x\n", acc_irq_stat);
break;
}
}
}
return IRQ_HANDLED;
}
static int snd_cs5535audio_free(struct cs5535audio *cs5535au)
{
synchronize_irq(cs5535au->irq);
pci_set_power_state(cs5535au->pci, 3);
if (cs5535au->irq >= 0)
free_irq(cs5535au->irq, cs5535au);
pci_release_regions(cs5535au->pci);
pci_disable_device(cs5535au->pci);
kfree(cs5535au);
return 0;
}
static int snd_cs5535audio_dev_free(struct snd_device *device)
{
struct cs5535audio *cs5535au = device->device_data;
return snd_cs5535audio_free(cs5535au);
}
static int __devinit snd_cs5535audio_create(struct snd_card *card,
struct pci_dev *pci,
struct cs5535audio **rcs5535au)
{
struct cs5535audio *cs5535au;
int err;
static struct snd_device_ops ops = {
.dev_free = snd_cs5535audio_dev_free,
};
*rcs5535au = NULL;
if ((err = pci_enable_device(pci)) < 0)
return err;
if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
printk(KERN_WARNING "unable to get 32bit dma\n");
err = -ENXIO;
goto pcifail;
}
cs5535au = kzalloc(sizeof(*cs5535au), GFP_KERNEL);
if (cs5535au == NULL) {
err = -ENOMEM;
goto pcifail;
}
spin_lock_init(&cs5535au->reg_lock);
cs5535au->card = card;
cs5535au->pci = pci;
cs5535au->irq = -1;
if ((err = pci_request_regions(pci, "CS5535 Audio")) < 0) {
kfree(cs5535au);
goto pcifail;
}
cs5535au->port = pci_resource_start(pci, 0);
if (request_irq(pci->irq, snd_cs5535audio_interrupt,
IRQF_SHARED, KBUILD_MODNAME, cs5535au)) {
snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
err = -EBUSY;
goto sndfail;
}
cs5535au->irq = pci->irq;
pci_set_master(pci);
if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
cs5535au, &ops)) < 0)
goto sndfail;
snd_card_set_dev(card, &pci->dev);
*rcs5535au = cs5535au;
return 0;
sndfail: /* leave the device alive, just kill the snd */
snd_cs5535audio_free(cs5535au);
return err;
pcifail:
pci_disable_device(pci);
return err;
}
static int __devinit snd_cs5535audio_probe(struct pci_dev *pci,
const struct pci_device_id *pci_id)
{
static int dev;
struct snd_card *card;
struct cs5535audio *cs5535au;
int err;
if (dev >= SNDRV_CARDS)
return -ENODEV;
if (!enable[dev]) {
dev++;
return -ENOENT;
}
err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
if (err < 0)
return err;
if ((err = snd_cs5535audio_create(card, pci, &cs5535au)) < 0)
goto probefail_out;
card->private_data = cs5535au;
if ((err = snd_cs5535audio_mixer(cs5535au)) < 0)
goto probefail_out;
if ((err = snd_cs5535audio_pcm(cs5535au)) < 0)
goto probefail_out;
strcpy(card->driver, DRIVER_NAME);
strcpy(card->shortname, "CS5535 Audio");
sprintf(card->longname, "%s %s at 0x%lx, irq %i",
card->shortname, card->driver,
cs5535au->port, cs5535au->irq);
if ((err = snd_card_register(card)) < 0)
goto probefail_out;
pci_set_drvdata(pci, card);
dev++;
return 0;
probefail_out:
snd_card_free(card);
return err;
}
static void __devexit snd_cs5535audio_remove(struct pci_dev *pci)
{
olpc_quirks_cleanup();
snd_card_free(pci_get_drvdata(pci));
pci_set_drvdata(pci, NULL);
}
static struct pci_driver cs5535audio_driver = {
.name = KBUILD_MODNAME,
.id_table = snd_cs5535audio_ids,
.probe = snd_cs5535audio_probe,
.remove = __devexit_p(snd_cs5535audio_remove),
#ifdef CONFIG_PM_SLEEP
.driver = {
.pm = &snd_cs5535audio_pm,
},
#endif
};
module_pci_driver(cs5535audio_driver);
MODULE_AUTHOR("Jaya Kumar");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("CS5535 Audio");
MODULE_SUPPORTED_DEVICE("CS5535 Audio");
|
__label__pos
| 0.982011 |
views:
126
answers:
7
I keep coming across the use of this word and I never understand its use or the meaning being conveyed.
Phrases like...
"add semantics for those who read"
"HTML5 semantics"
"semantic web"
"semantically correctly way to..."
... confuse me and I'm not just referring to the web. Is the word just another way to say "grammar" or "syntax"?
Thanks!
+2 A:
Check out this wiki page:
http://en.wikipedia.org/wiki/Semantics#Computer_science
Very good description.
Michael Bazos
+8 A:
Syntax is structure. Semantics is meaning. Each different context will give a different shade of meaning to the term.
HTML 5, for example, has new tags that are meant to provide meaning to the data that is wrapped in the tags. The <aside> tag conveys that the data contained within is tangentially-related to the information around itself. See, it is meaning, not markup.
Take a look at this list of HTML 5's new semantic tags. Contrast them against the old and more familiar HTML tags like <b>, <em>, <pre>, <h1>. Each one of those will affect the appearance of HTML content as rendered in a browser, but they can't tell us why. They contain no information of meaning.
Adam Crossland
A:
From my view, it's almost like looking at syntax in a grammatical way. I can't speak to semantics in a broad term, but When people talk about semantics on the web, they are normally referring to the idea that if you stripped away all of the css and javascript etc; what was left (the bare bones html) would make sense to be read.
It also takes into account using the correct tags for correct markup. This stems from the old table-based layouts (tables should only be used for tabular data), and using lists to present list-like content.
You wouldn't use an h1 for something that was less important than an h2. That wouldn't make sense.
cdutson
+1 A:
It is not just Computer Science terminology, and if you ask,
What is the meaning behind this Computer Science lingo?
then I'm afraid we'll get in a recursive loop just like this.
Anurag
haha... I wasn't aware of the recursive Google Search. That is hilarious!
Hristo
@Hristo - hehe, I don't click that link myself anymore. Impossible to get out :P
Anurag
+4 A:
It means "meaning", what you've got left when you've already accounted for syntax and grammar. For example, in C++ i++; is defined by the grammar as a valid statement, but says nothing about what it does. "Increment i by one" is semantics.
HTML5 semantics is what a well-formed HTML5 description is supposed to put on the page. "Semantic web" is, generally, a web where links and searches are on meaning, not words. The semantically correct way to do something is how to do it so it means the right thing.
David Thornley
ahh ok. that is simple enough... meaning. thank you
Hristo
+4 A:
Semantics are the meaning of various elements in the program (or whatever).
For example, let's look at this code:
int width, numberOfChildren;
Both of these variables are integers. From the compiler's point of view, they are exactly the same. However, judging by the names, one is the width of something, while the other is a count of some other things.
numberOfChildren = width;
Syntactically, this is 100% okay, since you can assign integers to each other. However, semantically, this is totally wrong, since the width and the number of children (probably) don't have any relationship. In this case, we'd say that this is semantically incorrect, even if the compiler permits it.
Mike Caron
Thanks. That makes a lot more sense.
Hristo
multiChildStroller.width = numberOfChildren
dkamins
+1 A:
In the HTML world, "semantic" is used to talk about the meaning of tags, rather than just considering how the output looks. For example, it's common to italicize foreign words, and it's also common to italicize emphasized words. You could simply wrap all foreign or emphasized words in <i>..</i> tags, but that only describes how they look, it doesn't describe why they look that way.
A better tag to use for emphasized word is <em>..</em>, because it conveys the semantics of emphasis. The browser (or your stylesheet) can then render them in italics, and other consumers of the page will know the word is emphasized. For example, a screen-reader could properly read it as an emphasized word.
Ned Batchelder
|
__label__pos
| 0.898445 |
[2016-Jun-NEW]Braindump2go New 1Z0-053 PDF Dump 676q Shared for Free Downloading[NQ81-NQ90]
2016 June Oracle Official 1Z0-053: Oracle Database 11g: Administration II Exam Questions New Updated Today in Braindump2go.com. 100% 1Z0-053 Exam Pass Guaranteed!
NEW QUESTION 81 – NEW QUESTION 90:
QUESTION 81
Your database has a backup that was taken yesterday (Tuesday) between 13:00 and 15:00 hours. This is the only backup you have. You have lost all the archived redo logs generated since the previous Monday, but you have archived redo logs available from the previous Sunday and earlier. You now need to restore your backup due to database loss. To which point can you restore your database?
A. 13:00 on Tuesday.
B. 15:00 on Tuesday.
C. Up until the last available archived redo log on Sunday.
D. To any point; all the redo should still be available in the online redo logs.
E. The database is not recoverable.
Answer: E
QUESTION 82
Which of the following files cannot be backed up by RMAN? (Choose all that apply.)
A. Database datafiles
B. Control files
C. Online redo logs
D. Database pfiles
E. Archived redo logs
Answer: CD
QUESTION 83
Which of the following RMAN structures can data from a datafile span?
A. RMAN backup-set pieces spanning backup sets
B. RMAN backup-set pieces within a given backup set
C. RMAN backups
D. RMAN channels
E. None of the above
Answer: B
QUESTION 84
Which RMAN backup command is used to create the block-change tracking file?
A. alter database create block change tracking file
B. alter database enable block change file
C. alter database enable block change tracking using file ,,/ora01/opt/ block_change_tracking.fil
D. alter system enable block change tracking using file ‘/ora01/opt/block_ change_tracking.fil’
E. alter system block change tracking on
Answer: C
Explanation:
http://docs.oracle.com/cd/E16655_01/backup.121/e17630/rcmbckba.htm#BRADV8125
QUESTION 85
A shoot-out has erupted between your MS development teams using .NET and your Linux development teams using Java.
Knowing that your database is in danger, which command would you use to back up your NOARCHIVELOG mode database using RMAN with compression?
A. backup database all
B. backup compressed database
C. backup as compressed backupset database;
D. backup as compressed backup database plus archivelog all;
E. backup as compressed backupset database plus compress archivelog all;
Answer: C
Explanation:
http://docs.oracle.com/cd/E11882_01/backup.112/e10642/rcmbckba.htm#BRADV8138
QUESTION 86
What is the purpose of the RMAN recovery catalog? (Choose all that apply.)
A. Make backups faster
B. Store RMAN metadata
C. Store RMAN scripts
D. Provide the ability to do centralized backup reporting.
E. Make recovery faster
Answer: BCD
Explanation:
A recovery catalog is a database schema used by RMAN to store metadata about one or more Oracle databases. Typically, you store the catalog in a dedicated database. A recovery catalog provides the following benefits:
A recovery catalog creates redundancy for the RMAN repository stored in the control file of each target database. The recovery catalog serves as a secondary metadata repository. If the target control file and all backups are lost, then the RMAN metadata still exists in the recovery catalog.
A recovery catalog centralizes metadata for all your target databases. Storing the metadata in a single place makes reporting and administration tasks easier to perform.
A recovery catalog can store metadata history much longer than the control file. This capability is useful if you must do a recovery that goes further back in time than the history in the control file. The added complexity of managing a recovery catalog database can be offset by the convenience of having the extended backup history available.
Some RMAN features function only when you use a recovery catalog. For example, you can store RMAN scripts in a recovery catalog. The chief advantage of a stored script is that it is available to any RMAN client that can connect to the target database and recovery catalog. Command files are only available if the RMAN client has access to the file system on which they are stored.
A recovery catalog is required when you use RMAN in a Data Guard environment. By storing backup metadata for all primary and standby databases, the catalog enables you to offload backup tasks to one standby database while enabling you to restore backups on other databases in the environment.
QUESTION 87
RMAN provides more granular catalog security through which feature?
A. Virtual private database
B. Virtual private catalog
C. RMAN virtual database
D. RMAN secure catalog
E. Oracle Database Vault
Answer: B
Explanation:
About Virtual Private Catalogs
By default, all of the users of an RMAN recovery catalog have full privileges to insert, update, and delete any metadata in the catalog. For example, if the administrators of two unrelated databases share the same recovery catalog, each administrator could, whether inadvertently or maliciously, destroy catalog data for the other’s database. In many enterprises, this situation is tolerated because the same people manage many different databases and also manage the recovery catalog. But in other enterprises where clear separation of duty exists between administrators of various databases, and between the DBA and the administrator of the recovery catalog, you may desire to restrict each database administrator to modify only backup metadata belonging to those databases that they are responsible for, while still keeping the benefits of a single, centrallymanaged, RMAN recovery catalog. This goal can be achieved by implementing virtual private catalogs.
QUESTION 88
You can back up the RMAN recovery catalog with RMAN.
A. True
B. False
Answer: A
Explanation:
When backing up the recovery catalog database, you can use RMAN to make the backups.
Refer to here.
QUESTION 89
What RMAN command must you use before you can back up a database using the recovery catalog?
A. create catalog
B. install database
C. catalog database
D. merge Catalog with database
E. register database
Answer: E
QUESTION 90
You have control-file autobackups enabled. When starting your database from SQL*Plus, you receive the following error message:
SQL> startup ORA-01078: failure in processing system parameters LRM-00109: could not open parameter file ,,
C:\ORACLE\PRODUCT\11.1.0\DB_1\DATABASE\INITORCL.ORA Using RMAN,
how would you respond to this error?
A. Issue the startup nomount command and then issue the restore parameter file command from the
RMAN prompt.
B. Issue the startup nomount command and then issue the restore spfile command from the RMAN
prompt.
C. Issue the startup nomount command and then issue the restore spfile from autobackup command
from the RMAN prompt.
D. Issue the startup nomount command and then issue the restore spfile from backup command from
the RMAN prompt.
E. Issue the restore spfile from autobackup command from the RMAN prompt.
Answer: C
2016 Valid Oracle 1Z0-053 Study Materials:
1.| Latest 1Z0-053 Exam PDF and VCE Dumps 676q from Braindump2go: http://www.braindump2go.com/1z0-053.html [100% Exam Pass Guaranteed!]
2.| New 1Z0-053 Exam Questions and Answers – Google Drive: https://drive.google.com/folderview?id=0B75b5xYLjSSNOGJaLVVucEZfS28&usp=sharing
MORE Practice is the Most Important IF You want to PASS Oracle 1Z0-053 Exam 100%!
————— Braindump2go.com
————— Pass All IT Exams at the first Try!
|
__label__pos
| 0.661348 |
欢迎访问
云南鼎浩信息技术有限公司官方网站,云南网站建设诚信品牌！
鼎浩网络,云南鼎浩信息技术有限公司
鼎浩客服热线
DING HAO COLUMN 鼎浩专栏
鼎浩的一些分享
Sharing from Ding Hao
• 鼎浩服务
• 1
使用jQuery+PHP+Mysql实现抽奖程序
来源：云南鼎浩 2013年07月02日17：02
字号：T|T
抽奖程序在实际生活中广泛运用，由于应用场景不同抽奖的方式也是多种多样的。本文将采用实例讲解如何利用jQuery+PHP+Mysql实现类似电视中常见的一个简单的抽奖程序。
本例中的抽奖程序要实现从海量手机号码中一次随机抽取一个号码作为中奖号码，可以多次抽奖，被抽中的号码将不会被再次抽中。抽奖流程：点击“开始”按钮后，程序获取号码信息，滚动显示号码，当点击“停止”按钮后，号码停止滚动，这时显示的号码即为中奖号码，可以点击“开始”按钮继续抽奖。
查看演示DEMO
HTML
上述代码中，我们需要一个#roll用来显示滚动号码，#mid是用来记录抽中的号码id，然后就是需要两个按钮分别用来“开始”和“停止”动作，最后还需要一个#result显示抽奖结果。
CSS
我们使用简单的css来修饰html页面。
.demo{width:300px; margin:60px auto; text-align:center}
#roll{height:32px; line-height:32px; font-size:24px; color:#f30}
.btn{width:80px; height:26px; line-height:26px; background:url(btn_bg.gif)
repeat-x; border:1px solid #d3d3d3; cursor:pointer}
#stop{display:none}
#result{margin-top:20px; line-height:24px; font-size:16px; text-align:center}
注意，我们默认将按钮#stop设置为display:none，是为了一开始只显示“开始”按钮，点击“开始”后，抽奖进行中，将显示“停止”按钮。
jQuery
我们首先要实现的是点击“开始”按钮，通过ajax从后台获取抽奖用的数据即手机号码，然后通过定时滚动显示手机号码，注意每次显示的手机号码是随机的，也就是说不是按照某种顺序出现的，我们看下面的代码：
$(function(){
var _gogo;
var start_btn = $("#start");
var stop_btn = $("#stop");
start_btn.click(function(){
$.getJSON('data.php',function(json){
if(json){
var obj = eval(json);//将JSON字符串转化为对象
var len = obj.length;
_gogo = setInterval(function(){
var num = Math.floor(Math.random()*len);//获取随机数
var id = obj[num]['id']; //随机id
var v = obj[num]['mobile']; //对应的随机号码
$("#roll").html(v);
$("#mid").val(id);
},100); //每隔0.1秒执行一次
stop_btn.show();
start_btn.hide();
}else{
$("#roll").html('系统找不到数据源，请先导入数据。');
}
});
});
});
首先我们定义变量，方便后续调用。然后，当点击“开始”按钮后，页面向后台data.php发送Ajax请求，这里我们使用jqeury的getJSON来完成异步请求。当后台返回json数据时，我们通过通过eval() 函数可以将JSON字符串转化为对象obj，其实就是将json数据转换为数组了。这时，我们使用setInterval做一个定时器，定时器里需要做的工作是：随机获取数组obj中的手机号码信息，然后显示在页面上。然后每隔0.1运行定时器，这样就达到了滚动显示抽奖号码的效果。同时显示“停止”按钮，隐藏“开始”按钮，这时抽奖进行中。
接下来看“停止”动作需要做的工作。
stop_btn.click(function(){
clearInterval(_gogo);
var mid = $("#mid").val();
$.post("data.php?action=ok",{id:mid},function(msg){
if(msg==1){
var mobile = $("#roll").html();
$("#result").append("
"+mobile+"
"); } stop_btn.hide(); start_btn.show(); }); });
当单击“停止”按钮，意味着抽奖结束。使用clearInterval()函数停止定时器，获取被抽中号码的id，然后通过$.post将选中号码id发送给后台data.php处理。应为被抽中的号码需要在数据库中标记。如果后台处理成功，前端将中奖号码追加到中奖结果中，同时隐藏“停止”按钮，显示“开始”按钮，可以再次抽奖了。
注意，我们使用setInterval()和clearInterval()设置定时器和停止定时器，关于这两个函数的使用大家可以google或百度下。
PHP
data.php需要做两件事，一，通过连接数据库，读取手机号码信息（不包好已中奖号码），然后通过转换成json格式输出给前端；二，通过接收前端请求，修改对应的数据库中的中奖号码状态，即标识该号码已中奖，下次将不再作为抽奖号码。
include_once('connect.php'); //连接数据库
$action = $_GET['action'];
if($action==""){ //读取数据，返回json
$query = mysql_query("select * from member where status=0");
while($row=mysql_fetch_array($query)){
$arr[] = array(
'id' => $row['id'],
'mobile' => substr($row['mobile'],0,3)."****".substr($row['mobile'],-4,4)
);
}
echo json_encode($arr);
}else{ //标识中奖号码
$id = $_POST['id'];
$sql = "update member set status=1 where id=$id";
$query = mysql_query($sql);
if($query){
echo '1';
}
}
我们可以看出，数据表member中有个字段叫status，这个字段是用来标识是否中奖。1表示已中奖，0表示未中奖。这个后台php程序就是操作数据库，然后返回对应的信息给前端。
MYSQL
最后将member表结构信息附上。
CREATE TABLE `member` (
`id` int(11) NOT NULL auto_increment,
`mobile` varchar(20) NOT NULL,
`status` tinyint(1) NOT NULL default '0',
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
关于抽奖程序，根据不同的应用场合不同的需求，会有不同的表现形式。接下来我们会有文章讲述如何按照不同的概率实现的抽奖程序，敬请关注helloweba.com
客服中心
点击进行在线咨询
QQ咨询 咨询QQ：79929313 咨询QQ：88139574 咨询QQ：122790803
咨询热线：0871-63399840
客服热线：0871-63523332
客服中心 客服中心
|
__label__pos
| 0.786415 |
Skip to content
Instantly share code, notes, and snippets.
Embed
What would you like to do?
Timely Greeting (2.0.1) A PHP script that you can use on your site to automatically display a greeting based on what time of day it is for the user. TO USE: See Readme.txt file
/*
* README.TXT -- TIMELY GREETING SCRIPT:
* By Nicolas Saad (www.nicolassaad.com)
* An PHP add-on script that you can use to automatically display a greeting based on what time of day it is for the user.
*
* INSTRUCTIONS:
* 1. To use put both greeting files in a folder named 'includes' inside your root directory. If you place them in a folder with a different name you will have to update the url in ajax request in timely-greeting.js so it matches the file's path.
* 2. Then add this line: include('includes/timely-greeting.js'); in your PHP code in the page where you want to use the script (inside the footer works fine).
* 3. Lastly, paste this tag where you want the greeting to display: <span class='timelyGreeting'></span>
* */
<?php
// Handle AJAX request
if( isset($_POST['value']) ){
// Storing the timezone offset from the jQuery code
$timezone_offset_minutes = $_POST['value'];
// Convert minutes to seconds
$timezone_name = timezone_name_from_abbr("", ($timezone_offset_minutes*60), false);
//JS code is needed to retrieve the user's timezone dynamically so we have it set statically for now
date_default_timezone_set($timezone_name);
// Morning start and end times 12:00AM - 11:59AM (12:00AM - 11:59AM)
$morningStart = '0000';
$morningEnd = '1159';
// Afternoon start and end times 12:00PM - 4:59PM (12:00PM - 4:59PM)
$afterNoonStart = '1200';
$afterNoonEnd = '1659';
// Evening start and end times 5:00PM - 11:59PM (5:00PM - 11:59PM)
$eveningStart = '1700';
$eveningEnd = '2359';
// The text greetings. **You can edit the values below but do not edit the keys**
$greetings = array(
"morning" => "Good morning",
"afternoon" => "Good afternoon",
"evening" => "Good evening"
);
// Retrieving the current time
$now = date('H:i');
// Removing the colon from the $now variable
$now = str_replace(":" , "" , "$now");
//Checking the current time of day in order to display the correct greeting
if ( ($now >= $morningStart) && ( $now <= $morningEnd ) ) {
echo $greetings["morning"];
} elseif ( ($now >= $afterNoonStart) && ( $now <= $afterNoonEnd) ) {
echo $greetings["afternoon"];
} elseif ( ($now >= $eveningStart) && ( $now <= $eveningEnd) ) {
echo $greetings["evening"];
}
exit;
}
var script = document.createElement('script');
script.src = '//code.jquery.com/jquery-1.11.0.min.js';
document.getElementsByTagName('head')[0].appendChild(script);
var d = new Date();
var month = d.getMonth();
var day = d.getDate();
var dow = d.getDay();
var timezone_offset_minutes = new Date().getTimezoneOffset();
timezone_offset_minutes = timezone_offset_minutes == 0 ? 0 : -timezone_offset_minutes; // if the offset is 0 leave it alone or else negate the offset value (example: 100 becomes -100).
console.log( "User's local TZ offset in minutes: " + timezone_offset_minutes); // logging the user's timezone offset in min
// Checks if DST is on and subtracts 60 minutes from the UTC offset to correctly adjust for Daylight Savings
if (isDST(day, month, dow)) { // isDST returns "true"
timezone_offset_minutes = timezone_offset_minutes - 60;
console.log("DST in North America is Currently ON (Started on the 2nd Sun of Mar & will end on the 1st Sun of Nov)");
} else { // isDST returns "false"
console.log("DST in North America is Currently OFF");
}
// Function that checks if DST in North America is on or off. Returns true for on and false for off.
function isDST(day, month, dow) {
//January, february, and december are out.
if (month < 2 || month > 10) { return false; }
//April to October are in
if (month > 2 && month < 10) { return true; }
var previousSunday = day - dow; //Getting the previous sunday day by subtracting the dow from the day of month.
//In march, we are DST if our previous sunday was on or after the 8th.
if (month == 2) { return previousSunday >= 8; }
//In november we must be before the first sunday to be in dst.
//That means the previous sunday must be before the 1st.
return previousSunday <= 0;
}
function fetchdata(){
$.ajax({
type: 'post',
data: {value: timezone_offset_minutes},
datatype: 'text',
url: 'includes/ajax-greeting.php', //If you didn't store the greeting files in a folder named 'includes' change url here
success: function(data){
// Perform operation on the return value
$('.timelyGreeting').text(data) /* Using 'exit;' at the end of if( isset($_POST['value']) in timely-greeting.php*/
}
});
}
$(document).ready(function(){
fetchdata(); // executing fetchdata() first so the greeting displays when the page loads
setInterval(fetchdata, 30000); // interval set to update greeting every 30 seconds. Greeting is updated live on the page without reloading
});
</script>
</body>
</html>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.
|
__label__pos
| 0.557009 |
Jump to content
• Log In with Google Sign In
• Create Account
C# delegates blow my mind
Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.
• You cannot reply to this topic
19 replies to this topic
#1 deadlydog Members - Reputation: 170
Like
0Likes
Like
Posted 14 May 2008 - 04:36 AM
I noticed that C# does not have an inline keyword for functions. Seeing this, I wanted to see how fast a function call was, and if it really made much of a difference putting the code inline VS putting it in a function call. I did a test executing the same code with 4 different approaches. The code executed in each approach is 9 operations (add and subtract). The 4 approaches are: 1 - putting the code all inline 2 - putting the code in a function and calling the function 3 - using a delegate to call the function 4 - putting each one of the 9 operations in their own function, and using a multicast delegate to call the 9 functions My goal was to see how many times the code could be executed in a specified length of time. I specify how long the approaches should run for and how many times they should be ran (the same values are used for all four approaches). I then take the average number of times the code was executed for each approach and compare them. I was expecting approach 1 to be the fastest, approaches 2 and 3 to be about the same, but much slower than approach 1, and approach 4 to be very slow. To my amazement appraoches 1, 2 and 3 all perform about the same, and approach 4 suffers maybe a 1% performance hit, if that. This was not the results that I was expecting. I have done the test many times, specifying different amounts of time the approaches should run for (1 - 60 seconds), and the number of times they should be ran (1 - 20, then take the average), and I get consistent results. Below is my code; I want to make sure that there is nothing I am overlooking. I use a high resolution Stopwatch to control how long each approach runs for, and I randomly pick the order that each of the 4 approaches is called in. Also, for the function calls I pass a class object as the single parameter, which is the object to update, and I make sure I'm not running any other applications when I do the test. If you can spot a potential problem in my code (or something that I am not considering) let me know. I just found this very interesting and thought I would share it.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
namespace Delegate_Speed_Test
{
public partial class Form1 : Form
{
// Class to hold data to update
class CParticle
{
public float f1;
public float f2;
public float f3;
public int i4;
public int i5;
public int i6;
public string s7;
public string s8;
public long l9;
public CParticle()
{
f1 = f2 = f3 = 0.0f;
i4 = i5 = i6 = 0;
s7 = s8 = "";
l9 = 0;
}
}
// Define the Delegate function structure
delegate void UpdateDelegate(CParticle cParticle);
// Variables used to calculate the average number of times executed
long mlNumberOfTimesRanInline = 0;
long mlNumberOfTimesRanFunction = 0;
long mlNumberOfTimesRanDelegate = 0;
long mlNumberOfTimesRanMulticastDelegate = 0;
Random mcRandom = new Random();
public Form1()
{
InitializeComponent();
UpdateShownTimeNeeded();
}
// Show how long the test will take to run using the given duration and number of times to run
private void UpdateShownTimeNeeded()
{
float fTimeInSeconds = (float)(numericNumberOfTimesToRun.Value * numericLengthOfTimeToRun.Value * 4);
float fTimeInMinutes = fTimeInSeconds / 60.0f;
labelTimeNeededToRunInSeconds.Text = fTimeInSeconds.ToString();
labelTimeNeededToRunInMinutes.Text = fTimeInMinutes.ToString();
}
// Start the test
private void buttonStart_Click(object sender, EventArgs e)
{
// Reset the number of times each has ran
mlNumberOfTimesRanInline = 0;
mlNumberOfTimesRanFunction = 0;
mlNumberOfTimesRanDelegate = 0;
mlNumberOfTimesRanMulticastDelegate = 0;
int iIndex = 0;
for (iIndex = 0; iIndex < numericNumberOfTimesToRun.Value; iIndex++)
{
// Call the functions in a random order
switch ((int)mcRandom.Next(0, 10))
{
default:
case 0:
Inline();
Function();
Delegate();
MulticastDelegate();
break;
case 1:
Function();
Delegate();
MulticastDelegate();
Inline();
break;
case 2:
Delegate();
MulticastDelegate();
Inline();
Function();
break;
case 3:
MulticastDelegate();
Inline();
Function();
Delegate();
break;
case 4:
MulticastDelegate();
Delegate();
Function();
Inline();
break;
case 5:
Inline();
MulticastDelegate();
Delegate();
Function();
break;
case 6:
Function();
Inline();
MulticastDelegate();
Delegate();
break;
case 7:
Delegate();
Function();
Inline();
MulticastDelegate();
break;
case 8:
Inline();
Delegate();
Function();
MulticastDelegate();
break;
case 9:
MulticastDelegate();
Function();
Delegate();
Inline();
break;
}
}
// Display Inline Info
double dAverageTimesRanInline = (double)mlNumberOfTimesRanInline / (double)numericNumberOfTimesToRun.Value;
labelNumberOfTimesInline.Text = dAverageTimesRanInline.ToString("#.###");
labelNumberOfTimesInlinePercent.Text = "100.0%";
// Display Function Info
double dAverageTimesRanFunction = (double)mlNumberOfTimesRanFunction / (double)numericNumberOfTimesToRun.Value;
labelNumberOfTimesFunction.Text = dAverageTimesRanFunction.ToString("#.###");
float fPercent = (float)((dAverageTimesRanFunction / dAverageTimesRanInline) * 100.0f);
labelNumberOfTimesFunctionPercent.Text = fPercent.ToString() + "%";
// Display Delegate Info
double dAverageTimesRanDelegate = (double)mlNumberOfTimesRanDelegate / (double)numericNumberOfTimesToRun.Value;
labelNumberOfTimesDelegate.Text = dAverageTimesRanDelegate.ToString("#.###");
fPercent = (float)((dAverageTimesRanDelegate / dAverageTimesRanInline) * 100.0f);
labelNumberOfTimesDelegatePercent.Text = fPercent.ToString() + "%";
// Display MulticastDelegate Info
double dAverageTimesRanMulitcastDelegate = (double)mlNumberOfTimesRanMulticastDelegate / (double)numericNumberOfTimesToRun.Value;
labelNumberOfTimesMulticastDelegate.Text = dAverageTimesRanMulitcastDelegate.ToString("#.###");
fPercent = (float)((dAverageTimesRanMulitcastDelegate / dAverageTimesRanInline) * 100.0f);
labelNumberOfTimesMulticastDelegatePercent.Text = fPercent.ToString() + "%";
}
// Approach 1 - Code inline
private void Inline()
{
long lNumberOfTimesExecuted = 0;
long lAmountOfTimeToRunFor = (long)(numericLengthOfTimeToRun.Value * 1000);
CParticle cParticle = new CParticle();
Stopwatch cStopwatch = new Stopwatch();
cStopwatch.Start();
while (cStopwatch.ElapsedMilliseconds < lAmountOfTimeToRunFor)
{
lNumberOfTimesExecuted++;
cParticle.f1 += 1.5f;
cParticle.f2 = 15.567f;
cParticle.f3 -= 0.0001f;
cParticle.i4 += 3;
cParticle.i5 = 23345;
cParticle.i6 -= 7;
cParticle.s7 = "Hello";
cParticle.s8 += "A";
cParticle.l9 += 123;
}
mlNumberOfTimesRanInline += lNumberOfTimesExecuted;
}
// Approach 2 - Code in a function call
private void Function()
{
long lNumberOfTimesExecuted = 0;
long lAmountOfTimeToRunFor = (long)(numericLengthOfTimeToRun.Value * 1000);
CParticle cParticle = new CParticle();
Stopwatch cStopwatch = new Stopwatch();
cStopwatch.Start();
while (cStopwatch.ElapsedMilliseconds < lAmountOfTimeToRunFor)
{
lNumberOfTimesExecuted++;
Update(cParticle);
}
mlNumberOfTimesRanFunction += lNumberOfTimesExecuted;
}
// Approach 3 - Code in a function call, called from a delegate
private void Delegate()
{
long lNumberOfTimesExecuted = 0;
long lAmountOfTimeToRunFor = (long)(numericLengthOfTimeToRun.Value * 1000);
UpdateDelegate MyDelegate = new UpdateDelegate(Update);
CParticle cParticle = new CParticle();
Stopwatch cStopwatch = new Stopwatch();
cStopwatch.Start();
while (cStopwatch.ElapsedMilliseconds < lAmountOfTimeToRunFor)
{
lNumberOfTimesExecuted++;
MyDelegate(cParticle);
}
mlNumberOfTimesRanDelegate += lNumberOfTimesExecuted;
}
// Approach 4 - Code in several function calls, each called from a multicast delegate
private void MulticastDelegate()
{
long lNumberOfTimesExecuted = 0;
long lAmountOfTimeToRunFor = (long)(numericLengthOfTimeToRun.Value * 1000);
UpdateDelegate MyDelegate = null;
MyDelegate += new UpdateDelegate(Update1);
MyDelegate += new UpdateDelegate(Update2);
MyDelegate += new UpdateDelegate(Update3);
MyDelegate += new UpdateDelegate(Update4);
MyDelegate += new UpdateDelegate(Update5);
MyDelegate += new UpdateDelegate(Update6);
MyDelegate += new UpdateDelegate(Update7);
MyDelegate += new UpdateDelegate(Update8);
MyDelegate += new UpdateDelegate(Update9);
CParticle cParticle = new CParticle();
Stopwatch cStopwatch = new Stopwatch();
cStopwatch.Start();
while (cStopwatch.ElapsedMilliseconds < lAmountOfTimeToRunFor)
{
lNumberOfTimesExecuted++;
MyDelegate(cParticle);
}
mlNumberOfTimesRanMulticastDelegate += lNumberOfTimesExecuted;
}
// Function containing code to run
private void Update(CParticle cParticle)
{
cParticle.f1 += 1.5f;
cParticle.f2 = 15.567f;
cParticle.f3 -= 0.0001f;
cParticle.i4 += 3;
cParticle.i5 = 23345;
cParticle.i6 -= 7;
cParticle.s7 = "Hello";
cParticle.s8 += "A";
cParticle.l9 += 123;
}
// Functions containing code to run (spread across several functions)
private void Update1(CParticle cParticle)
{
cParticle.f1 += 1.5f;
}
private void Update2(CParticle cParticle)
{
cParticle.f2 = 15.567f;
}
private void Update3(CParticle cParticle)
{
cParticle.f3 -= 0.0001f;
}
private void Update4(CParticle cParticle)
{
cParticle.i4 += 3;
}
private void Update5(CParticle cParticle)
{
cParticle.i5 = 23345;
}
private void Update6(CParticle cParticle)
{
cParticle.i6 -= 7;
}
private void Update7(CParticle cParticle)
{
cParticle.s7 = "Hello";
}
private void Update8(CParticle cParticle)
{
cParticle.s8 += "A";
}
private void Update9(CParticle cParticle)
{
cParticle.l9 += 123;
}
// If the user changed how long each approach should run for
private void numericLengthOfTimeToRun_ValueChanged(object sender, EventArgs e)
{
UpdateShownTimeNeeded();
}
// If the user changed how many times each approach should be run
private void numericNumberOfTimesToRun_ValueChanged(object sender, EventArgs e)
{
UpdateShownTimeNeeded();
}
}
}
-Dan- Can't never could do anything | DansKingdom.com | Dynamic Particle System Framework for XNA
#2 Sneftel Senior Moderators - Reputation: 1788
Like
0Likes
Like
Posted 14 May 2008 - 04:40 AM
Quote:
Original post by deadlydog
I noticed that C# does not have an inline keyword for functions.
Most C++ compilers ignore the "inline" keyword when determining whether or not to inline a function. Why should C# be any different?
The real issue, though, is JIT compiling, which is ideal for dynamic dispatch situations in which the same function is always chosen. JIT engines optimize for this situation (as do C++ compilers, in some circumstances), meaning that the difference between a delegate call and explicitly inlined code is usually just a pointer comparison.
EDIT: Actually, now that I look at it, the .NET runtime doesn't seem to do this.
[Edited by - Sneftel on May 14, 2008 11:40:17 AM]
#3 Washu Senior Moderators - Reputation: 7612
Like
0Likes
Like
Posted 14 May 2008 - 04:43 AM
You should perhaps read my blog posts on this very subject. Inlining in .Net is actually quite different than perhaps what you're used to.
#4 deadlydog Members - Reputation: 170
Like
0Likes
Like
Posted 14 May 2008 - 04:45 AM
Quote:
Original post by Sneftel
Quote:
Original post by deadlydog
I noticed that C# does not have an inline keyword for functions.
Most C++ compilers ignore the "inline" keyword when determining whether or not to inline a function. Why should C# be any different?
Yes, I know. the "inline" keyword is more of a hint to the compiler, rather than a strict rule it must follow. I was just blown away by how fast the function calls are; for example, in my test both the inline approach and the function call approach can execute the code 22000 times per second, even though the function call approach is making 22000 more function calls than the inline approach. So it seems that calling a function takes virtually no time at all. However, as I pointed out above, this is when passing a single parameter to the function, and it's passed by reference. If you were passing 10 parameters by value to the function, that may slow things down a bit.......hmmmm, I think I'll try that out.
-Dan- Can't never could do anything | DansKingdom.com | Dynamic Particle System Framework for XNA
#5 Sneftel Senior Moderators - Reputation: 1788
Like
0Likes
Like
Posted 14 May 2008 - 04:51 AM
Quote:
Original post by deadlydog
So it seems that calling a function takes virtually no time at all.
This is definitely true when the function call is in a correctly predicted branch. Modern processors see the branch coming up and prefetch the branched-to instructions, meaning that execution continues similarly to if there was no branch at all.
#6 -MadHatter Members - Reputation: 122
Like
0Likes
Like
Posted 14 May 2008 - 05:17 AM
reference types are passed by reference. value types are passed by value. anything declared as a struct is a value type, while things declared class are reference types.
default behavior for reference type passing is "sort of" by reference but not exactly. if you assign your parameter value to a new instance, it creates a new reference and the value of the variable passed into the method remains unchanged. modifying members of the reference type parameter will work like a by reference call.
the following method is how you really pass by reference in C# for both reference and value types.
public void Foo(ref MyObject mo) {
// ...
}
#7 Sneftel Senior Moderators - Reputation: 1788
Like
0Likes
Like
Posted 14 May 2008 - 05:29 AM
Quote:
Original post by -MadHatter
reference types are passed by reference. value types are passed by value. anything declared as a struct is a value type, while things declared class are reference types.
You seem to be confusing reference types with reference passing. C# passes both value and reference types by value, unless the ref keyword is given. The remainder of your post shows that you understand the practical upshot of C#'s system, but you should get your terminology straight. There's nothing "sort of" about C#'s evaluation strategy. ref variables are passed by reference; everything else, value type or reference type, is passed by value.
#8 deadlydog Members - Reputation: 170
Like
0Likes
Like
Posted 14 May 2008 - 05:44 AM
Quote:
Original post by Sneftel
Quote:
Original post by -MadHatter
reference types are passed by reference. value types are passed by value. anything declared as a struct is a value type, while things declared class are reference types.
You seem to be confusing reference types with reference passing. C# passes both value and reference types by value, unless the ref keyword is given. The remainder of your post shows that you understand the practical upshot of C#'s system, but you should get your terminology straight. There's nothing "sort of" about C#'s evaluation strategy. ref variables are passed by reference; everything else, value type or reference type, is passed by value.
So does this mean that it's faster to pass my class object with the ref keyword (since you say this is the only way to make it actually pass the reference (i.e. pointer in c++ speak) of the object, not a copy of it)?
Thanks
-Dan- Can't never could do anything | DansKingdom.com | Dynamic Particle System Framework for XNA
#9 Washu Senior Moderators - Reputation: 7612
Like
0Likes
Like
Posted 14 May 2008 - 05:44 AM
Quote:
Original post by Sneftel
Quote:
Original post by -MadHatter
reference types are passed by reference. value types are passed by value. anything declared as a struct is a value type, while things declared class are reference types.
You seem to be confusing reference types with reference passing. C# passes both value and reference types by value, unless the ref keyword is given. The remainder of your post shows that you understand the practical upshot of C#'s system, but you should get your terminology straight. There's nothing "sort of" about C#'s evaluation strategy. ref variables are passed by reference; everything else, value type or reference type, is passed by value.
Heh, that's one thing that's so much easier to explain using C++ :D.
#10 DevFred Members - Reputation: 840
Like
0Likes
Like
Posted 14 May 2008 - 05:48 AM
Quote:
Original post by deadlydog
since you say this is the only way to make it actually pass the reference (i.e. pointer in c++ speak) of the object, not a copy of it
He didn't say that at all. If you pass a reference type, the reference gets passed by value, NOT THE OBJECT. You only need to pass reference types by reference if you want to change the reference (NOT THE OBJECT) inside of the function.
#11 TheTroll Members - Reputation: 883
Like
0Likes
Like
Posted 14 May 2008 - 06:28 AM
Quote:
Original post by Sneftel
Quote:
Original post by -MadHatter
reference types are passed by reference. value types are passed by value. anything declared as a struct is a value type, while things declared class are reference types.
You seem to be confusing reference types with reference passing. C# passes both value and reference types by value, unless the ref keyword is given. The remainder of your post shows that you understand the practical upshot of C#'s system, but you should get your terminology straight. There's nothing "sort of" about C#'s evaluation strategy. ref variables are passed by reference; everything else, value type or reference type, is passed by value.
Think I need to clear something up here before people get confused.
First of all we will go over some terms to make sure we are all on the same page.
reference type and value type - these are the two base types, value types are structs and other base types such as int, float, ect. When you use a value type a copy of the information is made and that is used. A reference type (classes) are used by reference, so when you use them the reference is passed around not the data itself.
reference parameters vs. value parameters. Unless you use the 'ref' keyword, the parameter for a method will be a value parameter, so the parameter will be passed by value.
So what does this mean to us? Well that is where it gets a little strange.
take the fallowing
DoSomething(myClass a);
That is a value parameter, so we are passing it by value but what does it really mean? It means that we are coping the data. So what data gets copied? The reference to a gets copied and passed in. So why is this important? Let me show you.
void DoSomething(myClass a)
{
a = new myClass();
a.Text = "Did something";
}
So we do this.
myClass first = new myClass();
first.Text = "Some text";
Now we call the function.
DoSomething(first);
What will be the value of first.Text when we are done? It will still be "Some text";
Now we call the functions using a function call like so; void DoSomething(ref myClass a);
What will the value of first.Text be when you are done? "Did something".
So why is that? Because in this case we are passing the acutal reference to first and not just a copy. In the first case we changed the reference and so we were no longer referencing 'first', in the second one we were always referencing 'first'.
I really hope that didn't confuse anyone. By value of a reference is just a copy of the reference and doesn't really matter unless you change the reference.
theTroll
#12 DevFred Members - Reputation: 840
Like
0Likes
Like
Posted 14 May 2008 - 06:52 AM
Quote:
Original post by TheTroll
Because in this case we are passing the acutal reference to first and not just a copy.
No, it's because we pass the reference by reference.
#13 Structural Members - Reputation: 328
Like
0Likes
Like
Posted 14 May 2008 - 06:58 AM
Quote:
Original post by Washu
You should perhaps read my blog posts on this very subject. Inlining in .Net is actually quite different than perhaps what you're used to.
Now that was an interesting read. One thing popped in my mind though. In some "dumb" compilers you can optimize looping over an array sequentially by using running pointers:
for (int i = 0; i < count; i++)
{
x += array[i]; // array[i]: extra instructions for calculating the memory address of the value
}
can be optimized into:
int* ptr = array;
int* end = array + count;
while (ptr < end)
{
x += *ptr;
ptr++;
}
In an embedded audio processing project I did recently this simple optimization resulted in 10-20% fewer instructions for functions that were mainly made up of such loops.
Note though that the processing was relatively simple and was mainly made up of loops like these. The things that were done inside the loop every iteration was not much.
But what I was wondering is if the JIT will pick up on optimizations like these or if the "foreach" keyword can play a role here? A search on "foreach vs for loops" does not turn up anything that indicates this though, but I can't help but wonder.
Now, I do realize that for games this is less of an issue as the heavy number crunching does not depend on looping over arrays, but for video and audio processing this is more of an issue where you are constantly looping over buffers.
#14 TheTroll Members - Reputation: 883
Like
0Likes
Like
Posted 14 May 2008 - 07:07 AM
Quote:
Original post by DevFred
Quote:
Original post by TheTroll
Because in this case we are passing the acutal reference to first and not just a copy.
No, it's because we pass the reference by reference.
No, it works exactly as I described. Why don't you test it and you will be a bit shocked.
This exact thing bit me hard when I first started working in C#.
theTroll
#15 SamLowry Members - Reputation: 1865
Like
0Likes
Like
Posted 14 May 2008 - 08:24 AM
Quote:
Original post by TheTroll
Quote:
Original post by DevFred
Quote:
Original post by TheTroll
Because in this case we are passing the acutal reference to first and not just a copy.
No, it's because we pass the reference by reference.
No, it works exactly as I described. Why don't you test it and you will be a bit shocked.
This exact thing bit me hard when I first started working in C#.
theTroll
No, it's because the reference is passed by reference.
I'm not saying it doesn't behave as you described, it's your explanation that's not correct. But it's possible that in the end, it's just a terminology issue.
But what is certain, is that it does work with a reference-to-a-reference-to-an-object.
#16 TheTroll Members - Reputation: 883
Like
0Likes
Like
Posted 14 May 2008 - 08:36 AM
No, the reference is passed by-value, unless you specify 'ref'.
So you have a copy of the reference, not the reference. Now in most cases this does not matter, it works the same. The exception is if you try to create a new object based on that reference. Because it is a copy of the reference and not the original reference when you do a new you do create a new object, but it's reference is assigned to the copy of the reference not to the original one. So then you will loose what you just created.
This is covered under parameters in the C# Standard.
"12.1.4 Value parameters
A parameter declared without a ref or out modifier is a value parameter.
A value parameter comes into existence upon invocation of the function member (method, instance
constructor, accessor, or operator) to which the parameter belongs, and is initialized with the value of the
argument given in the invocation. A value parameter ceases to exist upon return of the function member
(except when the value parameter is captured by an anonymous method (§14.5.15.3.1) or the function
member body is an iterator block (§26))."
theTroll
P. S. Just for some mucilaginous information. DoSomething(myClass a) and DoSomething(ref myClass a) are different in relation to function overloading. So both would be allowed without giving you an error. Makes sense just never thought of it before.
#17 DevFred Members - Reputation: 840
Like
0Likes
Like
Posted 14 May 2008 - 08:46 AM
Quote:
Original post by TheTroll
Quote:
Original post by DevFred
Quote:
Original post by TheTroll
Because in this case we are passing the acutal reference to first and not just a copy.
No, it's because we pass the reference by reference.
No, it works exactly as I described. Why don't you test it and you will be a bit shocked.
It does work as you described, and I never doubted that.
All I'm saying is that your terminology is a bit fuzzy. The reason it works as described is because if you use the ref keyword, the reference gets passed by reference instead of by value. This does not make the reference more "actual".
#18 TheTroll Members - Reputation: 883
Like
0Likes
Like
Posted 14 May 2008 - 08:50 AM
With all the cold medication I am on right now, I am a bit surprised I was not talking about pink bunnies. Also typed that holding a 4 month old that is sick also. So yeah, the terminology could have been much better.
Just didn't wanted to try to make sure that folks understood there is a difference between passing by-reference and passing a reference by-value.
theTroll
#19 DevFred Members - Reputation: 840
Like
0Likes
Like
Posted 14 May 2008 - 09:06 AM
Quote:
Original post by TheTroll
there is a difference between passing by-reference and passing a reference by-value.
That is the gist of it, yes.
The problem is that in C# and Java, pointers were (restricted and) renamed to "references", so there are certain types that consist of values called "references". Since these references are values, expressions can yield references, you can store references in variables etc.
In C++ we have a clear distinction between pointers and references. In C++, pointers are values (addresses of objects*), whereas references are not. A reference variable is just another name for some object, there are no references to references (because a reference is not an object) etc.
References were introduced in C++ to support call-by-reference semantics in operator overloading (so user-defined types could be used just as built-in types). The concepts "reference" and "call-by-reference" are closely related in C++.
In Java there is only call-by-value (primitive types are passed by value and reference types are passed by value), and there are no user-defined value types (classes always define reference types). So the term "reference" always means "reference to an object", which is a value.
In C#, there are user-defined reference types (classes) and user-defined value types (structs), and there is call-by-value and call-by-reference. You can
- pass value types by value (the object is copied)
- pass value types by reference (the original object is used)
- pass reference types by value (the reference is copied)
- pass reference types by reference (the original reference is used)
So you have to be very carefully when you talk about the word "reference" in C#. Do you mean the reference to an instance of a class (a value), or do you mean "call-by-reference" (a parameter passing mechanism involving the keyword ref)?
* In C++, an object is something that consumes memory and has an address. Don't confuse this with the term "object" in "OOP". I bet Zahlman can come up with a better definition though ;)
[Edited by - DevFred on May 14, 2008 3:06:21 PM]
#20 -MadHatter Members - Reputation: 122
Like
0Likes
Like
Posted 27 May 2008 - 04:19 AM
unlike java, you can still use normal pointers in .NET, but yea, they renamed managed pointers to handles in .net.
Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.
PARTNERS
|
__label__pos
| 0.583808 |
S1C11ACT02B Alternate Angles (Interior)Theorem (Slide)
In the applet below, a TRANSVERSAL intersects 2 PARALLEL LINES. When this happens, there are 2 pairs of ALTERNATE ANGLES (INTERIOR) that are formed. Interact with the applet below for a few minutes, then answer the questions that immediately follow.
Directions & Questions: 1) Complete the following statement: If a transversal intersects 2 ________________ ______________, then alternate interior angles are _____________________. 2) If the pink angle above measures 134 degrees, what would the measure of its alternate interior angle be? 3) As you moved the slider, what transformation(s) took place?
|
__label__pos
| 0.905136 |
Network Working Group E. Harslem Request for Comments: 80 J. Heafner NIC: 5608 RAND 1 December 1970 PROTOCOLS AND DATA FORMATS Because of recent discussions of protocols and data formats we issue this note to highlight our current attitudes and investigations in those regards. We first discuss some specific sequences, and then offer some thoughts on two general implementation approaches that will handle these and other specifics. We wish to place emphasis on the _general solutions_ and not on the specifics. INITIAL CONNECTION PROTOCOLS We wish to make two points concerning specific Initial Connection Protocols (IPCs). Firstly, the IPC described in NEW/RFC #66--its generality and a restatement of that ICP. Secondly, a proposal for a variant ICP using basically the same logic as NWG/RFC #66. I. NWG/RFC #66 The only technical error in this IPC is that as diagrammed both the Server and User send ALL messages before the connections are established which is inconsistent with Network Document No. 1. This can easily be remedied as will be shown in the restatement below. In terms of generality, any ICP that is adopted as a standard should apply to more situations than a process calling a logger. That is, some Network service processes that hook directly to a user process, independent of logger action, could perhaps use a standard ICP. Thus, as is shown below, the process name field of the server socket should be a parameter with a value of zero being a special case for loggers. Restatement of NWG/RFC #66 (using the same wording where appropriate) 1. To initiate contact, the using process attaches a receive socket (US) and requests connection to process SERV socket #1 in the serving HOST. (SERV = 0 for ICP to the logger.) As a result the using NCP sends: Harslem, et. al. [Page 1] RFC 80 Protocols and Data Formats 1 December 1970 1 4 3 1 1 +-----+---------------------+---------------+-----+-----+ | RTS | US | SERV | 1 | P | +-----+---------------------+---------------+-----+-----+ over link 1, where P is the receive link. 2. The serving process (SERV) may decide to refuse to the call, in which case it closes the connection. If it accepts the call, the serving process completes the connection (via an INIT system call, hence an STR). 1 3 1 4 +-----+----------------+-----+--------------------+ | STR | SERV | 1 | US | +-----+----------------+-----+--------------------+ 3. When the connection is completed, the user process allocates a nominal amount of space to the connection, resulting in the NCP sending: 1 1 4 +-----+-----+--------------------+ | ALL | P | SPACE | +-----+-----+--------------------+ where SPACE is the amount. 4. The serving process then selects the socket pair it wishes to assign this user. It sends exactly an even 32 bit number over the connection. This even 32 bit number (SS) is the receive socket in the serving HOST. This socket and the next higher numbered socket are reserved for the using process. 5. It then closes the connection. The serving NCP sends (step 4): 4 +---------------------+ | SS | +---------------------+ on link P, and (step 5): Harslem, et. al. [Page 2] RFC 80 Protocols and Data Formats 1 December 1970 1 3 1 4 +-----+----------------+-----+--------------------+ | CLS | SERV | 1 | US | +-----+----------------+-----+--------------------+ on the control link (which is echoed by the using NCP). 6. Now that both server and user are aware of the remote socket pair for the duplex connection, s can be exchanged. _Sever sends User_ 1 4 4 +-----+--------------------+--------------------+ | STR | SS + 1 | US | +-----+--------------------+--------------------+---+ | RTS | SS | SS + 1 | Q | +-----+--------------------+--------------------+---+ where Q is the Server's receive link. _User sends Server_ 1 4 4 +-----+--------------------+--------------------+ | STR | US + 1 | SS | +-----+--------------------+--------------------+---+ | RTS | US | SS + 1 | R | +-----+--------------------+--------------------+---+ where R is the User's receive link. ALLocates may then be sent and transmission begun. II. A Variation of NWG/RFC #66 This variation reduces Network messages and eliminates duplication of information transfer. Steps 3 and 4 above are deleted. The user process is not notified directly which of the Server's sockets it will be assigned. The user process, however, will listen on sockets US and US + 1 for calls from SERV after step 5 above. It can reject any spurious calls. In accepting the calls from SERV, the connection is established. The following sample sequence illustrates this ICP. (The notation is as above). Harslem, et. al. [Page 3] RFC 80 Protocols and Data Formats 1 December 1970 1. User --> Server 1 4 3 1 1 +-----+--------------------+----------------+-----+-----+ | RTS | US | SERV | 1 | P | +-----+--------------------+----------------+-----+-----+ 2. Server --> User If accepted: 1 3 1 4 +-----+----------------+-----+---------------------+ | STR | SERV | 1 | US | +-----+----------------+-----+---------------------+ | CLS | SERV | 1 | US | +-----+----------------+-----+---------------------+ If rejected: 1 3 1 4 +-----+----------------+-----+---------------------+ | CLS | SERV | 1 | US | +-----+----------------+-----+---------------------+ 3. If accepted, user listens on US and US + 1. 4. Server --> User 1 4 4 +-----+--------------------+---------------------+ | STR | SS + 1 | US | +-----+--------------------+---------------------+---+ | RTS | SS | US + 1 | Q | +-----+--------------------+---------------------+---+ 5. User accepts the calls, hence: User --> Sender 1 4 4 +-----+---------------------+--------------------+ | STR | US + 1 | SS + 1 | +-----+---------------------+--------------------+---+ | RTS | US + 1 | SS | R | +-----+---------------------+--------------------+---+ and the connection is established. Harslem, et. al. [Page 4] RFC 80 Protocols and Data Formats 1 December 1970 This reduces the number of network messages by two and only passes the information regarding the Server's sockets once via RTS and STR. PRE-SPECIFIED DATA FORMATS We would like to adopt those suggestions for data formats in NWG/RFC #42 and #63. We subscribe to multiple standards as solutions to particular problem classes. AN ADAPTABLE MECHANISM We would like to adapt to Network use, problem programs that were not planned with the Network in mind, and which, no doubt, will not easily succumb to Network standards existing at the time of their inclusion. This incompatibility problem is just as fundamental a part of the research underlying the Network as is different Host hardware. To require extensive front-ends on each such program is not a reasonable goal. We view the Network as an amalgamation of a) Hosts that provide services; b) parasite Hosts that interface terminals to the services, and c) a spectrum of Hosts that behave as both users and providers of services. To require that each parasite Host handle different protocols and data formats for all services that its users need is not a reasonable goal. The result is programs and terminals that wish to communicate but do not speak the same language. One approach to the protocol and data format problems is to provide an adaptable mechanism that programs and terminals can use to easily access Network resources. ARPA is sponsoring the Adaptive Communicator Project at Rand which is a research effort to investigate a teachable front-end process to interface man to program. The variety of terminal devices being explored include voice, tablets, sophisticated graphics terminals, etc. The Adaptive Communicator looks very encouraging but it will not be ready for some time. The Network Project at Rand chose to take the adaptable approach (_not_ adaptive, i.e., no heuristics, no self-learning). Our problem is to get Rand researchers onto the Network easily, assuming that they have different simultaneous applications calling for different program protocols and data configurations. Protocols and data formats will be described separately to illustrate what we mean by adaptation. Protocols are sequences of "system calls" that correspond to (and result in NCP's issuance of) NCP commands. Data formats are the descriptions of regular message contents and are not meaningful to an NCP. Harslem, et. al. [Page 5] RFC 80 Protocols and Data Formats 1 December 1970 The Form Machine (adapting to data formats) To put the reader in context, the Form Machine is of the class of finite state machines that recognize a form of _regular_ expressions_ which, in our case, describe data formats. The notation, however, is aimed at particular descriptions and therefore can be more succinct, for our purposes, than the language of regular expressions. The Form Machine is an experimental software package that couples a variety of programs and terminals whose data format requirements are different. We envision Form Machines located (to reduce Network traffic) at various service providing Hosts. To test the Form Machine idea, we are implementing two IBM OS- callable subroutines; a compiler that compiles statements which describe forms of data formats; and an executor that executes a compiled form on a data stream. To describe the Form Machine test, it is necessary to mention another program at Rand--the Network Services Program (NSP), which is a multi-access program that interfaces the Network Control Program both to arbitrary programs and to Video Graphics Consoles. (We view a terminal as just another program with a different interface, i.e., # characters/line, # lines/page, unique hardware features, the application to which it is put, etc.) The Form Machine subroutines are callable from NSP upon consoles or program direction. Operationally, a console user names and specifies the data forms that he will use. The forms are compiled and stored for later use. At some future time when the user wishes to establish Network connections and transmit data, he dynamically associates named forms with each side of a port--a symbolically named Network full duplex connection. Data streams incoming or outgoing are executed according to the compiled form and the transformed data stream is then passed along to the console/program or to the Network, respectively. The details of the syntax of our Form Machine notation are unimportant to the collective Network community. However, the provisions of the notation are of interest. It will eventually encompass the description of high performance CRT displays, TTY, and arbitrary file structures. To test its viability, a subset of such features is being implemented. Harslem, et. al. [Page 6] RFC 80 Protocols and Data Formats 1 December 1970 The current version is characterized by the following features: 1) Character code translation (viz., decimal, octal, hexidecimal, 8 bit ASCII, 7 bit ASCII, EBCDIC, and binary). 2) Multiple break strings (many terminals have multiple termination signals). 3) Insertion of literals (used primarily for display information presentation). 4) Skip or delete arbitrary strings (used to remove record sequence numbers, etc., that are not to be displayed). 5) Record sequence number generation. 6) String-length computation and insertion. 7) _Arbitrary_ data string length specifications, e.g., "a hex literal string followed by an _arbitrary_ number of EBCDIC characters, followed by a break string, .....". 8) Concatenation of Network messages, i.e., the execution of compiled forms on incomplete data strings. 9) Data field transposition. 10) Both explicit and indefinite multiplicative factors for both single and multi-line messages. Features that are not being implemented but will be added, if successful, include: 1) Graphics oriented descriptions. 2) General number translations. 3) Conditional statements. 4) A pointer capability. The Protocol Manager (adapting to NCP command sequences) The NSP allows terminal users and programs to work at the NCP protocol level; i.e., LISTEN, INIT, et al. It also allows them to transmit and massage information meaningful only to themselves. This "hands-on" approach is desirable from the systems Harslem, et. al. [Page 7] RFC 80 Protocols and Data Formats 1 December 1970 programmer's, or exploratory point of view. However, it is desirable to eliminate the laborious "handshaking" for the researcher who repeatedly uses a given remote program by allowing him to define, store, retrieve, and execute "canned" protocol sequences. We are currently specifying a Protocol Manager as a module of NSP that will allow the above operations on NCP command sequences. Features of the module are: 1) The sequences may contain "break points" to permit the console user to dynamically inject any contextually needed information. 2) The parameters of a command may contain tokens whose values are supplied by the remote party during the protocol dialog. For example, in Note #66 the socket number provided by the server is to be used by the user in subsequent RTS, STR commands. REQUEST We would like to hear from anyone concerning the notion of adaptation to data formats and protocol. Is this a reasonable approach? What should it encompass? JFH:EFH:hs Harslem, et. al. [Page 8] RFC 80 Protocols and Data Formats 1 December 1970 Distribution Albert Vezza, MIT Alfred Cocanower, MERIT Gerry Cole, SDC Bill English, SRI Bob Flegel, Utah James Forgie, LL Peggy Karp, MITRE Nico Haberman, Carnegie-Mellon John Heafner, RAND Bob Kahn, BB&N Margie Lannon, Harvard James Madden, Univ. of Ill. Thomas O'Sullivan, Raytheon Larry Roberts, ARPA Robert Sproull, Stanford Ron Stoughton, UCSB Chuck Rose, Case University Benita Kirstel, UCLA [This RFC was put into machine readable form for entry] [into the online RFC archives by Lorrie Shiota, 10/01] Harslem, et. al. [Page 9] RFC Document downloaded from http://www.meotoo.com/
|
__label__pos
| 0.645468 |
LESS and incron: CSS at its finest
less is, once again, more.
less is, once again, more.
Web development is full of challenges. That’s my nice way of saying writing CSS blows. CSS is powerful, but at the cost of being too fine grained and low level for easy development. It’s like the assembly of web design. Other developers are all-too-aware of the situation and have come up with a few solutions, including CSS frameworks, which reduce the amount of from-scratch code and provide a system (e.g., Blueprint or the 960 grid system), versus the freeform mess of raw CSS, and CSS extensions, like LESS, which is the topic of the day.
Act One: L-E-S-S spells bliss
If you aren’t using something like this yet, you might as well be punching yourself in the crotch every time you code.
I have also messed with Sass, which was not as “Syntactically Awesome” as LESS, and xCSS, which was overkill (but I might revisit it later). LESS is good because:
• Any standard CSS file is a valid LESS file – easy to only use the features you need
• Just as powerful as Sass, offering variables, functions, nesting, CSS-specialized math operations
• Aptana CSS highlighting works great:
1. Go: Window->Preferences
2. General->Editors->File Associations
3. Add file type: *.less
4. Add editor: Aptana CSS Editor (right at the top)
I mean, look at this syntax:
@left_column_width: 300px;
@column_margin_width: 15px;
/** Palette **/
@light_blue: #d0dae3;
@pastel_blue: #7492ac;
@med_blue: #1e5d97;
@dark_blue: #0b3c68;
@light_orange: #f6b860;
@pastel_orange: #dfab62;
@med_orange: #e9951f;
@dark_orange: #a1630c;
/** Colors **/
@top_nav_color: @light_blue;
@top_nav_hover_color: @light_orange;
@header_color: @pastel_blue;
#header {
clear:both;
float:left;
width:100%;
border-bottom:1px solid @dark_blue - #111;
background: @header_color;
padding-bottom: 12px;
margin-bottom: 7px;
.page-title {
float:left;
clear:none;
display:inline;
}
}
/***** Two column layout a la *********
****** http://matthewjamestaylor.com/blog/ultimate-2-column-left-menu-pixels.htm *****/
/* column container */
.colmask {
position:relative;
clear:both;
float:left;
width:100%;
/*overflow:hidden;*/
}
/* 2 column left menu settings */
.leftmenu {
background:#fff;
overflow:hidden;
.colright {
float:left;
width:200%;
position:relative;
left: @left_column_width + (2 * @column_margin_width);
background:#fff;
}
.col1wrap {
float:right;
width:50%;
position:relative;
right: @left_column_width + (3 * @column_margin_width);
padding-bottom:1em;
}
.col1 {
margin:0 @column_margin_width 0 (@left_column_width + (4 * @column_margin_width));
position:relative;
right:100%;
/*overflow:hidden;*/
}
.col2 {
float:left;
width: @left_column_width ;
position:relative;
right: @left_column_width + @column_margin_width;
}
}
Now you have an easily customizable two column layout and color scheme. Change your values in one place and they gracefully propagate. If you wanted to change the colors or column width before, you would have to change dozens of values. Really, stop what you’re doing, change your CSS file’s extension to .less, and become a happier person.
Act Two: Incron
So the only problem that I ran into is the bump in the workflow: compiling from LESS to CSS. This is where incron comes into play. Incron monitors files for changes and can trigger actions as specified by you with a cron-like syntax we can all love. I have a little Gentoo development box I use; I put incron on it and set it to run lessc whenever my LESS file changed. Just install/emerge incron, run incrontab -e and add one line:
/path/to/less/files/mystyles.less IN_MODIFY lessc $@
Now you’ll have a file called my_styles.css and everything will be hunky dory. Of course this could easily be extended to do more powerful things with your styles, like move them into the right place or give them fancy names or version them or whatever. The potential here is also not limited to LESS, so consider it an investment. If this intrigues you, I think this tutorial should be all you need for now.
Well, web development is a big basket of ugly and this only addresses one aspect. There’s still cross-browser grossness and JavaScript debugging horror. But LESS helps. LESS helps.
10 responses to “LESS and incron: CSS at its finest
1. This post warms my heart
2. Ha, I knew you would come around. SASS sucks (compared to LESS).
3. Haha, Sass seems to be more popular, which might give it an edge with features/maturity/whatever as a result of wider usage and development, but thus far not in any way that is very appreciable.
The difference between LESS and Sass is the difference between 1% and 2% milk when you have been eating your cereal with laundry detergent.
4. Awesome Blog thank you. After the Design and Development of the website comes SEO. If you would like to share a software that helps with off site seo reporting check out http://www.mofikiworldwide.com/mofikis_seo_analyzer.php and thank you for this blog.
5. Pingback: SILT: Canvas/SVG, jQuery, LESS update « Superdrivel
6. I’m loving LESS! I’m running into issues in Aptana. It seems that all the CSS syntax errors that are features of LESS are bogging down the editor. Have you had similar issues? Do you know of a way to shut off the error handling for .less files?
7. Pingback: Incron, un cron guiado por eventos inotify « Geek's Story
8. very helpfull thanx tutorial.
9. Admin do you want unlimited content for your wordpress blog?
Serarch in google:
Anightund’s rewriter
10. Pingback: Incron – Un cron basado en eventos | Blog Nº 13
Leave a Reply
Fill in your details below or click an icon to log in:
WordPress.com Logo
You are commenting using your WordPress.com account. Log Out / Change )
Twitter picture
You are commenting using your Twitter account. Log Out / Change )
Facebook photo
You are commenting using your Facebook account. Log Out / Change )
Connecting to %s
|
__label__pos
| 0.700152 |
ヘッダ・フッタ - header/footer
①ヘッダ/フッタの生成 ☆ソース 1.ヘッダー <div data-role="header"><h1>ヘッダ</h1></div> 2.フッター <div data-role="footer"><h1>フッタ</h1></div>
デモ
1.ヘッダー
ヘッダ
2.フッター
フッタ
②ボタン付きヘッダ/フッタ ☆ソース 1.ボタン付きヘッダ <div data-role="header"><button>ボタン１</button></div> 2.複数ボタン付きヘッダ <div data-role="header"> <button>ボタン１</button> <button>ボタン２</button> <button>ボタン３</button> </div> 3.両端ボタン付きヘッダ <div data-role="header"> <a>ボタン左</a> <a>ボタン右</a> <h1>ヘッダ</h1> </div> 3.補足:ここではaタグを使います。h1を加えないとヘッダが潰れてしまいます。潰れなければ他(button等で)で代替も可能です。 4.グループボタン付きヘッダ <div data-role="header"> <div data-role="controlgroup" data-type="horizontal"> <button>ボタン１</button> <button>ボタン２</button> <button>ボタン３</button> <button>ボタン４</button> </div> </div> data-role="header"⇒data-role="footer"にすれば、フッタでも同じように使えます。
デモ
①ボタン付きヘッダ
②複数ボタン付きヘッダ
③両端ボタン付きヘッダ
4.グループボタン付きヘッダ
③固定・フルスクリーン設定・ナビゲーションバー
これらは、実際のページで解説します。
1.固定ヘッダ・フッタ
2.フルスクリーン設定
3.ナビゲーションバー
|
__label__pos
| 0.627339 |
Incremental Integration Model characteristics - Basic concepts of Software Testing
Q. Which of the following are / is the characteristics of Incremental Integration Model?
1. Defects are easy to detect.
2. All the modules are required to be completed before integration testing starts.
3. It is time consuming.
4. Stubs and Drivers are used.
- Published on 13 Aug 15
a. 2, 4
b. 1, 3, 4
c. 1, 2, 4
d. All of the above
ANSWER: 1, 3, 4
Discussion
• Prajakta Pandit -Posted on 17 Nov 15
- In incremental model, the whole requirement is divided into various builds.
- It is the process of verifying the interfaces and interaction between modules.
- In this model, the defects are found earlier in a smaller assembly, when it is relatively easy to detect the root cause of the same.
Characteristics of Incremental Integration Model
- Defects are easy to detect.
- Stubs and drivers are used. The developers integrate the modules one by one using stubs and drivers to uncover the defects.
- It is a time consuming process.
Post your comment / Share knowledge
Enter the code shown above:
(Note: If you cannot read the numbers in the above image, reload the page to generate a new one.)
|
__label__pos
| 0.996535 |
Hello I'm new to PHP, here's what I'm haveing trouble with. I'm using php to display a gallery in a directory and delete the images, but I get an error when I try to use the delete button and I don't know why or how to fix it, can anyone help?
Parse error: syntax error, unexpected $end in /delete.php on line 22
Here is the code on the page:
<form name="form1" method="post" action="delete.php">
<?php
$path = "test";
$dir_handle = @opendir($path) or die("Unable to open folder");
while (false !== ($file = readdir($dir_handle))) {
if($file == "index.php")
continue;
if($file == ".")
continue;
if($file == "..")
continue;
echo "<input type=CHECKBOX name=$file>";
echo "<img src='$file' alt='$file'><br />";
}
closedir($dir_handle);
?>
<input type="submit" name="Delete" value="Delete">
</form>
And here is the delete.php code (line 22 is the end of the code ?>):
<?php
$path = "test";
$dir_handle = @opendir($path) or die("Unable to open folder");
//We list the name of the files again, since the name of the checkbox is the same with the name of the file
while (false !== ($file = readdir($dir_handle))) {
if($file == "index.php")
continue;
if($file == ".")
continue;
if($file == "..")
continue;
if(isset($_POST[$file])){
$checkbox = $_POST[$file];
if($checkbox == on) { //checkbox is selected
//Delete the file
if(!unlink($file)) die("Failed to delete file");
}
}
?>
Recommended Answers
All 8 Replies
close your while statement
Thanks for replying Rob I no longer get an error, but now when I click on delete the page refreshes but the image is still there, any idea's?
Here's what the code looks like now"
<form name="form1" method="post">
<?php
$path = "test";
$dir_handle = @opendir($path) or die("Unable to open folder");
while (false !== ($file = readdir($dir_handle))) {
if($file == "index.php")
continue;
if($file == ".")
continue;
if($file == "..")
continue;
echo "<input type=CHECKBOX name=$file>";
echo "<img src='$file' alt='$file'><br />";
}
closedir($dir_handle);
?>
<?php
$path = "test";
$dir_handle = @opendir($path) or die("Unable to open folder");
while (false !== ($file = readdir($dir_handle))) {
if($file == "index.php")
continue;
if($file == ".")
continue;
if($file == "..")
continue;
if(isset($_POST[$file])){
$checkbox = $_POST[$file];
if($checkbox == on) {
if(!unlink($file)) die("Failed to delete file");
}
}}
?>
<input type="submit" name="Delete" value="Delete">
</form>
the problem is that when you post a variable name that includes a ".", the "." is automatically replaced with an "_". You can see that by putting print_r($_POST); at the top of your file.
I'm looking for a fix now.
moved the delete block to the top so the file is deleted before you fill the form with the current existing files. Included current url redirect to refresh after the post(just a personal preference) because I think is reflects a better experience for the user to not have to worry about reposting every time the user wants to refresh the page after a post. Changed the checkbox name to an array, and the script loops through all the checked items of the array.
<?php
$path = "test";
if(isset($_POST['file']) && is_array($_POST['file']))
{
foreach($_POST['file'] as $file)
{
unlink($path . "/" . $file) or die("Failed to delete file");
}
header("location: " . $_SERVER['REQUEST_URI']); //redirect after deleting files so the user can refresh without that resending post info message
}
?>
<form name="form1" method="post">
<?php
$path = "test";
$dir_handle = @opendir($path) or die("Unable to open folder");
while (false !== ($file = readdir($dir_handle))) {
if($file == "index.php")
continue;
if($file == ".")
continue;
if($file == "..")
continue;
echo "<input type='CHECKBOX' name='file[]' value='$file'>";
echo "<img src='$file' alt='$file'><br />";
}
closedir($dir_handle);
?>
<input type="submit" name="Delete" value="Delete">
</form>
Rob u are my hero, i got an error with the header though so after searching around the net and ending up with nothing i just deleted the line that had the header, which was on line 10 of the above post. So now the file unlinks perfectly, Thank You! But now when i reload the original page the pictures still show up, although when i check the directory the files are not there, any idea why the pictures still show up?
Here's what I have:
<?php
$path = "test";
if(isset($_POST['file']) && is_array($_POST['file']))
{
foreach($_POST['file'] as $file)
{
unlink($path . "/" . $file) or die("Failed to delete file");
}
}
?>
<form name="form1" method="post">
<?php
$path = "test";
$dir_handle = @opendir($path) or die("Unable to open folder");
while (false !== ($file = readdir($dir_handle))) {
if($file == "index.php")
continue;
if($file == ".")
continue;
if($file == "..")
continue;
echo "<input type='CHECKBOX' name='file[]' value='$file'>";
echo "<img src='$file' alt='$file'><br />";
}
closedir($dir_handle);
?>
<input type="submit" name="Delete" value="Delete">
</form>
And in case deleting header("location: http://www.mysite.com/cp.php" . $_SERVER); is the cause of my current problem the error i get is:
Warning: Cannot modify header information - headers already sent by (output started at /public_html/cp.php:18) in /public_html/cp.php on line 68
That happens when you send anything to the browser before trying to redirect, even a blank line. So if your "<?php" starts on line 2, you will get an error if you try to redirect at any point in the script.
As far as the images still being there, the redirect probably will solve the problem because I think it is browser cache. You say the images aren't in the directory anymore but they still appear on the page right? ya browser cache. Try to get the redirect to work. If you can't get it to work, post your entire script because according to that error, you sent headers prior to the redirect, which means that you are not including something above this block of script, right?
Ya ur right it was the browser cache, i clued into that right after i posted the issue, so the code does work. Thank you again. If your interested in the redirect I'll post whole code im using.
<html>
<head>
<title></title>
<meta name="description" content="">
</head>
<body background="backborder.jpg">
<BODY TOPMARGIN=0>
<TABLE cellSpacing=0 cellPadding=0 width="80%" align=center border=1 bordercolor=#FFFF40>
<TR>
<TD align=left bgcolor="#C0C0FF">
<TABLE cellSpacing=0 cellPadding=0 width="100%" align=center background=homepage.jpg
border=0>
<TR>
<TD align=center background=images/targetbanner2.jpg colSpan=0 height=100>
<H1 align=center>
<img src="title.gif">
<br>
</H1></TD>
<TD colSpan=2>
</TR></table>
<br>
<br>
<table width="500" border="1" align="center" cellpadding="0" cellspacing="1" bgcolor="#CCCCCC">
<tr>
<form action="upload_ac.php" method="post" enctype="multipart/form-data" name="form1" id="form1">
<td>
<table width="100%" border="0" cellpadding="3" cellspacing="1" bgcolor="#FFFFFF">
<tr>
<td><strong>Multiple Files Upload </strong></td>
</tr>
<tr>
<td>Select file
<input name="ufile[]" type="file" id="ufile[]" size="50" /></td>
</tr>
<tr>
<td>Select file
<input name="ufile[]" type="file" id="ufile[]" size="50" /></td>
</tr>
<tr>
<td>Select file
<input name="ufile[]" type="file" id="ufile[]" size="50" /></td>
</tr>
<tr>
<td align="center"><input type="submit" name="Submit" value="Upload" /></td>
</tr>
</table>
</td>
</form>
</tr>
</table>
<br>
<?php
$path = "test";
if(isset($_POST['file']) && is_array($_POST['file']))
{
foreach($_POST['file'] as $file)
{
unlink($path . "/" . $file) or die("Failed to delete file");
}
}
?>
<form name="form1" method="post">
<?php
$path = "test";
$dir_handle = @opendir($path) or die("Unable to open folder");
while (false !== ($file = readdir($dir_handle))) {
if($file == "index.php")
continue;
if($file == ".")
continue;
if($file == "..")
continue;
echo "<input type='CHECKBOX' name='file[]' value='$file'>";
echo "<img src='$file' alt='$file'><br />";
}
closedir($dir_handle);
?>
<input type="submit" name="Delete" value="Delete">
</form>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
</TD>
</TR></table>
</body>
</html>
Be a part of the DaniWeb community
We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, learning, and sharing knowledge.
|
__label__pos
| 0.71821 |
Part 2: Introducing Mongoose to Your Node.js and Restify API
Nick Parsons
#Technical
This post is a sequel to Getting Started with MongoDB, Node.js and Restify. We’ll now guide you through the steps needed to modify your API by introducing Mongoose. If you have not yet created the base application, please head back and read the original tutorial.
In this post, we’ll do a deep dive into how to integrate Mongoose, a popular ODM (Object -Document Mapper) for MongoDB, into a simple Restify API. Mongoose is similar to an ORM (Object-Relational Mapper) you would use with a relational database. Both ODMs and ORMs can make your life easier with built-in structure and methods. The structure of an ODM or ORM will contain business logic that helps you organize data. The built in methods of an ODM or ORM automate common tasks that help you communicate with the native drivers, which helps you work more quickly and efficiently.
All of that said, the beauty of a tool like MongoDB is that ODMs are more of a convenience, as compared to how ORMs are essential for RDBMS’. MongoDB has many built in features for helping you organize, analyze and keep track of your data. In order to harness the added structure and logic that an ODM like Mongoose offers, we are going to show you how to incorporate it into your API.
Mongoose is an ODM that provides a straightforward and schema-based solution to model your application data on top of MongoDB’s native drivers. It includes built-in type casting, validation (which enhances MongoDB’s native document validation), query building, hooks and more.
Note: If you’d like to jump ahead without following the detailed steps below, the complete git repo for this tutorial can be found on GitHub.
Prerequisites
In order to get up to speed, let’s make sure that you are all set with the following prerequisites:
• An understanding of the original API
• The latest version of Node.js (currently at v8.1.4)
• A Mac (OSX, macOS, etc. as this tutorial does not cover Windows or Linux)
• git (installed by default on macOS)
Getting Started
This post assumes that you have the original codebase from the previous blog post. Please follow the instructions below to get up and running. I’ve included commands to pull in the example directory from the first post.
$ git clone [email protected]:nparsons08/mongodb-node-restify-api-part-1.git
$ cp -R mongodb-node-restify-api-part-1 mongodb-node-restify-api-part-2
$ cd mongodb-node-restify-api-part-2 && npm install
With the third command above, you have successfully copied the initial codebase into its own directory, which enables us to start the migration. To view the directories on your system, use the following command:
$ ls
You should see the following output:
$ mongodb-node-restify-api-part-1 mongodb-node-api-restify-part-2
Move into the new directory with the cd command and let’s begin the migration from the raw MongoDB driver to Mongoose:
$ cd mongodb-node-restify-api-part-2
New Dependencies
We’ll need to install additional dependencies in order to add the necessary functionality. Specifically, we’ll be adding mongoose and the mongoose-timestamp plugin to generate/store createdAt and updatedAt timestamps (we’ll touch more on Mongoose plugins later in the post).
$ npm install --save mongoose mongoose-timestamp
Since we’re moving away from the native MongoDB driver over to Mongoose, let’s go ahead and remove the dependency on the MongoDB driver using the following npm command:
$ npm uninstall mongodb
Now, if you view your package.json file, you will see the following JSON:
{
"name": "rest-api",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"start": "node index.js",
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [],
"author": "Nick Parsons <[email protected]>",
"license": "ISC",
"dependencies": {
"mongoose": "^4.11.1",
"mongoose-timestamp": "^0.6.0",
"restify": "^4.3.1"
}
}
Mongoose Schemas & Models
When you’re developing an application backend using Mongoose, your document design starts with what is called a schema. Each schema in Mongoose maps to a specific MongoDB collection.
With Mongoose schemas come models, a constructor compiled from the schema definition. Instances of models represent a MongoDB document, which can be saved and retrieved from your database. All document creation and retrieval from MongoDB is handled by a specific model. It’s important to know that schemas are extremely flexible and allow for the same nested structure as the native MongoDB driver would support. Furthermore, schemas support business logic such as validation, pre/post hooks, plugins, and more – all of which is outlined in the official Mongoose guide.
In the following steps, we’ll be adding two schema definitions to our codebase and, in turn, we will import them into our API routes for querying and document creation. The first model will be used to store all user data and the second will be used to store all associated todo items. This will create a functional and flexible structure for our API.
Schema/Model Creation
Assuming you’re inside of the root directory, create a new directory called models with a user.js and todo.js file:
$ mkdir models && cd models && touch user.js todo.js
Next, let’s go ahead and modify our models/user.js and models/todo.js models. The model files should have the following contents:
models/user.js
const mongoose = require('mongoose'),
timestamps = require('mongoose-timestamp')
const UserSchema = new mongoose.Schema({
email: {
type: String,
trim: true,
lowercase: true,
unique: true,
required: true,
},
name: {
first: {
type: String,
trim: true,
required: true,
},
last: {
type: String,
trim: true,
required: true,
},
},
}, { collection: 'users' })
UserSchema.plugin(timestamps)
module.exports = exports = mongoose.model('User', UserSchema)
models/todo.js
const mongoose = require('mongoose'),
timestamps = require('mongoose-timestamp')
const TodoSchema = new mongoose.Schema({
userId: {
type: mongoose.Schema.Types.ObjectId,
ref: 'User',
index: true,
required: true,
},
todo: {
type: String,
trim: true,
required: true,
},
status: {
type: String,
enum: [
'pending',
'in progress',
'complete',
],
default: 'pending',
},
}, { collection: 'todos' })
TodoSchema.plugin(timestamps)
module.exports = exports = mongoose.model('Todo', TodoSchema)
Note: We’re using the mongoose-timestamp plugin by calling SchemaName.plugin(timestamps). This allows us to automatically generate createdAt and updatedAt timestamps and indexes without having to add additional code to our schema files. A full breakdown on schema plugins can be found here.
Route Creation
The /routes directory will hold our user.js and todo.js files. For the sake of simplicity, you can copy and paste the following file contents into your todo.js file and overwrite the previous code. If you compare the two files, you’ll notice there is a slight change in the way that we call MongoDB using Mongoose. Specifically, Mongoose is playing as a role of abstraction over our database model, piping operations to the native MongoDB driver with validation in between.
Lastly, we’ll need to create a new file called user.js.
$ cd ../routes
Then create the routes/user.js file:
$ touch user.js
routes/user.js
const User = require('../models/user'),
Todo = require('../models/todo')
module.exports = function(server) {
/**
* Create
*/
server.post('/users', (req, res, next) => {
let data = req.body || {}
User.create(data)
.then(task => {
res.send(200, task)
next()
})
.catch(err => {
res.send(500, err)
})
})
/**
* List
*/
server.get('/users', (req, res, next) => {
let limit = parseInt(req.query.limit, 10) || 10, // default limit to 10 docs
skip = parseInt(req.query.skip, 10) || 0, // default skip to 0 docs
query = req.query || {}
// remove skip and limit from query to avoid false querying
delete query.skip
delete query.limit
User.find(query).skip(skip).limit(limit)
.then(users => {
res.send(200, users)
next()
})
.catch(err => {
res.send(500, err)
})
})
/**
* Read
*/
server.get('/users/:userId', (req, res, next) => {
User.findById(req.params.userId)
.then(user => {
res.send(200, user)
next()
})
.catch(err => {
res.send(500, err)
})
})
/**
* Update
*/
server.put('/users/:userId', (req, res, next) => {
let data = req.body || {},
opts = {
new: true
}
User.findByIdAndUpdate({ _id: req.params.userId }, data, opts)
.then(user => {
res.send(200, user)
next()
})
.catch(err => {
res.send(500, err)
})
})
/**
* Delete
*/
server.del('/users/:userId', (req, res, next) => {
const userId = req.params.userId
User.findOneAndRemove({ _id: userId })
.then(() => {
// remove associated todos to avoid orphaned data
Todo.deleteMany({ _id: userId })
.then(() => {
res.send(204)
next()
})
.catch(err => {
res.send(500, err)
})
})
.catch(err => {
res.send(500, err)
})
})
}
routes/todo.js
const Todo = require('../models/todo')
module.exports = function(server) {
/**
* Create
*/
server.post('/users/:userId/todos', (req, res, next) => {
let data = Object.assign({}, { userId: req.params.userId }, req.body) || {}
Todo.create(data)
.then(task => {
res.send(200, task)
next()
})
.catch(err => {
res.send(500, err)
})
})
/**
* List
*/
server.get('/users/:userId/todos', (req, res, next) => {
let limit = parseInt(req.query.limit, 10) || 10, // default limit to 10 docs
skip = parseInt(req.query.skip, 10) || 0, // default skip to 0 docs
query = req.params || {}
// remove skip and limit from data to avoid false querying
delete query.skip
delete query.limit
Todo.find(query).skip(skip).limit(limit)
.then(tasks => {
res.send(200, tasks)
next()
})
.catch(err => {
res.send(500, err)
})
})
/**
* Get
*/
server.get('/users/:userId/todos/:todoId', (req, res, next) => {
Todo.findOne({ userId: req.params.userId, _id: req.params.todoId })
.then(todo => {
res.send(200, todo)
next()
})
.catch(err => {
res.send(500, err)
})
})
/**
* Update
*/
server.put('/users/:userId/todos/:todoId', (req, res, next) => {
let data = req.body || {},
opts = {
new: true
}
Todo.update({ userId: req.params.userId, _id: req.params.todoId }, data, opts)
.then(user => {
res.send(200, user)
next()
})
.catch(err => {
res.send(500, err)
})
})
/**
* Delete
*/
server.del('/users/:userId/todos/:todoId', (req, res, next) => {
Todo.findOneAndRemove({ userId: req.params.userId, _id: req.params.todoId })
.then(() => {
res.send(204)
next()
})
.catch(err => {
res.send(500, err)
})
})
}
Entry Point
Our updated entry point for this API is in /index.js. Your index.js file should mirror the following:
/**
* Module Dependencies
*/
const restify = require('restify'),
mongoose = require('mongoose')
<p>/**</p>
<ul>
<li>Config
*/
const config = require('./config')</li>
</ul>
<p>/**</p>
<ul>
<li>Initialize Server
*/
const server = restify.createServer({
name : config.name,
version : config.version
})</li>
</ul>
<p>/**</p>
<ul>
<li>Bundled Plugins (http://restify.com/#bundled-plugins)
*/
server.use(restify.jsonBodyParser({ mapParams: true }))
server.use(restify.acceptParser(server.acceptable))
server.use(restify.queryParser({ mapParams: true }))
server.use(restify.fullResponse())</li>
</ul>
<p>/**</p>
<ul>
<li>
<p>Start Server, Connect to DB & Require Route Files
*/
server.listen(config.port, () => {</p>
<p>/**</p>
<ul>
<li>Connect to MongoDB via Mongoose
*/
const opts = {
promiseLibrary: global.Promise,
server: {
auto_reconnect: true,
reconnectTries: Number.MAX_VALUE,
reconnectInterval: 1000,
},
config: {
autoIndex: true,
},
}</li>
</ul>
<p>mongoose.Promise = opts.promiseLibrary
mongoose.connect(config.db.uri, opts)</p>
<p>const db = mongoose.connection</p>
<p>db.on('error', (err) => {
if (err.message.code === 'ETIMEDOUT') {
console.log(err)
mongoose.connect(config.db.uri, opts)
}
})</p>
<p>db.once('open', () => {</p>
<pre><code> require('./routes/user')(server)
require('./routes/todo')(server)
console.log(`Server is listening on port ${config.port}`)
})
})
Starting the Server
Now that we’ve modified the code to use Mongoose, let’s go ahead and run the npm start command from your terminal:
$ npm start
Assuming all went well, you should see the following output:
Server is listening on port 3000
Using the API
The API is almost identical to the API written in the "getting started" post, however, in this version we have introduced the concept of “users” who are owners of “todo” items. I encourage you to experiment with the new API endpoints using Postman to better understand the API endpoint structure.
For your convenience, below are the available calls (cURL) for your updated API endpoints:
User Endpoints
CREATE
curl -i -X POST http://localhost:3000/users -H 'content-type: application/json' -d '{ "email": "[email protected]", "name": { "first": "Nick", "last": "Parsons" }}'
LIST
curl -i -X GET http://localhost:3000/users -H 'content-type: application/json'
READ
curl -i -X GET http://localhost:3000/users/$USER_ID -H 'content-type: application/json'
UPDATE
curl -i -X PUT http://localhost:3000/users/$USER_ID -H 'content-type: application/json' -d '{ "email": "[email protected]" }'
DELETE
curl -i -X DELETE http://localhost:3000/users/$USER_ID -H 'content-type: application/json'
Todo Endpoints
CREATE
curl -i -X POST http://localhost:3000/users/$USER_ID/todos -H 'content-type: application/json' -d '{ "todo": "Make a pizza!" }'
LIST
curl -i -X GET http://localhost:3000/users/$USER_ID/todos -H 'content-type: application/json'
READ
curl -i -X GET http://localhost:3000/users/$USER_ID/todos/$TODO_ID -H 'content-type: application/json'
UPDATE
curl -i -X PUT http://localhost:3000/users/$USER_ID/todos/$TODO_ID -H 'content-type: application/json' -d '{ "status": "in progress" }'
DELETE
curl -i -X DELETE http://localhost:3000/users/$USER_ID/todos/$TODO_ID -H 'content-type: application/json'
Note: The $PARAM_ID requirement in the URL denotes that the URL parameter should be replaced with a value. In our case, it will likely be a MongoDB ObjectId.
Final Thoughts
I hope this short tutorial on adding Mongoose to your API was helpful for future development. Hopefully, you noticed how using a tool like Mongoose can simplify writing MongoDB functionality as a layer on top of your API.
As Mongoose is only a single addition to keep in mind as you develop and hone your API development skills, we’ll continue to release more posts with other examples and look forward to hearing your feedback. If you have any questions or run into issues, please comment below.
In my next post, I’ll show you how to create a similar application from start to finish using MongoDB Stitch, our new Backend as a Service. You'll get to see how abstracting away this API in favor of using Stitch will make it easier to add additional functionality such as database communication, authentication and authorization, so you can focus on what matters – the user experience on top of your API.
|
__label__pos
| 0.847099 |
require 5; package Pod::Simple; use strict; use Carp (); BEGIN { *DEBUG = sub () {0} unless defined &DEBUG } use integer; use Pod::Escapes 1.04 (); use Pod::Simple::LinkSection (); use Pod::Simple::BlackBox (); #use utf8; use vars qw( $VERSION @ISA @Known_formatting_codes @Known_directives %Known_formatting_codes %Known_directives $NL ); @ISA = ('Pod::Simple::BlackBox'); $VERSION = '3.23'; @Known_formatting_codes = qw(I B C L E F S X Z); %Known_formatting_codes = map(($_=>1), @Known_formatting_codes); @Known_directives = qw(head1 head2 head3 head4 item over back); %Known_directives = map(($_=>'Plain'), @Known_directives); $NL = $/ unless defined $NL; #----------------------------------------------------------------------------- # Set up some constants: BEGIN { if(defined &ASCII) { } elsif(chr(65) eq 'A') { *ASCII = sub () {1} } else { *ASCII = sub () {''} } unless(defined &MANY_LINES) { *MANY_LINES = sub () {20} } DEBUG > 4 and print "MANY_LINES is ", MANY_LINES(), "\n"; unless(MANY_LINES() >= 1) { die "MANY_LINES is too small (", MANY_LINES(), ")!\nAborting"; } if(defined &UNICODE) { } elsif($] >= 5.008) { *UNICODE = sub() {1} } else { *UNICODE = sub() {''} } } if(DEBUG > 2) { print "# We are ", ASCII ? '' : 'not ', "in ASCII-land\n"; print "# We are under a Unicode-safe Perl.\n"; } # Design note: # This is a parser for Pod. It is not a parser for the set of Pod-like # languages which happens to contain Pod -- it is just for Pod, plus possibly # some extensions. # @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ #@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ __PACKAGE__->_accessorize( 'nbsp_for_S', # Whether to map S<...>'s to \xA0 characters 'source_filename', # Filename of the source, for use in warnings 'source_dead', # Whether to consider this parser's source dead 'output_fh', # The filehandle we're writing to, if applicable. # Used only in some derived classes. 'hide_line_numbers', # For some dumping subclasses: whether to pointedly # suppress the start_line attribute 'line_count', # the current line number 'pod_para_count', # count of pod paragraphs seen so far 'no_whining', # whether to suppress whining 'no_errata_section', # whether to suppress the errata section 'complain_stderr', # whether to complain to stderr 'doc_has_started', # whether we've fired the open-Document event yet 'bare_output', # For some subclasses: whether to prepend # header-code and postpend footer-code 'nix_X_codes', # whether to ignore X<...> codes 'merge_text', # whether to avoid breaking a single piece of # text up into several events 'preserve_whitespace', # whether to try to keep whitespace as-is 'strip_verbatim_indent', # What indent to strip from verbatim 'parse_characters', # Whether parser should expect chars rather than octets 'content_seen', # whether we've seen any real Pod content 'errors_seen', # TODO: document. whether we've seen any errors (fatal or not) 'codes_in_verbatim', # for PseudoPod extensions 'code_handler', # coderef to call when a code (non-pod) line is seen 'cut_handler', # ... when a =cut line is seen 'pod_handler', # ... when a =pod line is seen 'whiteline_handler', # ... when a line with only whitespace is seen #Called like: # $code_handler->($line, $self->{'line_count'}, $self) if $code_handler; # $cut_handler->($line, $self->{'line_count'}, $self) if $cut_handler; # $pod_handler->($line, $self->{'line_count'}, $self) if $pod_handler; # $wl_handler->($line, $self->{'line_count'}, $self) if $wl_handler; 'parse_empty_lists', # whether to acknowledge empty =over/=back blocks ); #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ sub any_errata_seen { # good for using as an exit() value... return shift->{'errors_seen'} || 0; } #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ # Pull in some functions that, for some reason, I expect to see here too: BEGIN { *pretty = \&Pod::Simple::BlackBox::pretty; *stringify_lol = \&Pod::Simple::BlackBox::stringify_lol; } #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ sub version_report { my $class = ref($_[0]) || $_[0]; if($class eq __PACKAGE__) { return "$class $VERSION"; } else { my $v = $class->VERSION; return "$class $v (" . __PACKAGE__ . " $VERSION)"; } } #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ #sub curr_open { # read-only list accessor # return @{ $_[0]{'curr_open'} || return() }; #} #sub _curr_open_listref { $_[0]{'curr_open'} ||= [] } sub output_string { # Works by faking out output_fh. Simplifies our code. # my $this = shift; return $this->{'output_string'} unless @_; # GET. require Pod::Simple::TiedOutFH; my $x = (defined($_[0]) and ref($_[0])) ? $_[0] : \( $_[0] ); $$x = '' unless defined $$x; DEBUG > 4 and print "# Output string set to $x ($$x)\n"; $this->{'output_fh'} = Pod::Simple::TiedOutFH->handle_on($_[0]); return $this->{'output_string'} = $_[0]; #${ ${ $this->{'output_fh'} } }; } sub abandon_output_string { $_[0]->abandon_output_fh; delete $_[0]{'output_string'} } sub abandon_output_fh { $_[0]->output_fh(undef) } # These don't delete the string or close the FH -- they just delete our # references to it/them. # TODO: document these #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ sub new { # takes no parameters my $class = ref($_[0]) || $_[0]; #Carp::croak(__PACKAGE__ . " is a virtual base class -- see perldoc " # . __PACKAGE__ ); return bless { 'accept_codes' => { map( ($_=>$_), @Known_formatting_codes ) }, 'accept_directives' => { %Known_directives }, 'accept_targets' => {}, }, $class; } # TODO: an option for whether to interpolate E<...>'s, or just resolve to codes. #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ sub _handle_element_start { # OVERRIDE IN DERIVED CLASS my($self, $element_name, $attr_hash_r) = @_; return; } sub _handle_element_end { # OVERRIDE IN DERIVED CLASS my($self, $element_name) = @_; return; } sub _handle_text { # OVERRIDE IN DERIVED CLASS my($self, $text) = @_; return; } #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ # # And now directives (not targets) sub accept_directive_as_verbatim { shift->_accept_directives('Verbatim', @_) } sub accept_directive_as_data { shift->_accept_directives('Data', @_) } sub accept_directive_as_processed { shift->_accept_directives('Plain', @_) } sub _accept_directives { my($this, $type) = splice @_,0,2; foreach my $d (@_) { next unless defined $d and length $d; Carp::croak "\"$d\" isn't a valid directive name" unless $d =~ m/^[a-zA-Z][a-zA-Z0-9]*$/s; Carp::croak "\"$d\" is already a reserved Pod directive name" if exists $Known_directives{$d}; $this->{'accept_directives'}{$d} = $type; DEBUG > 2 and print "Learning to accept \"=$d\" as directive of type $type\n"; } DEBUG > 6 and print "$this\'s accept_directives : ", pretty($this->{'accept_directives'}), "\n"; return sort keys %{ $this->{'accept_directives'} } if wantarray; return; } #-------------------------------------------------------------------------- # TODO: document these: sub unaccept_directive { shift->unaccept_directives(@_) }; sub unaccept_directives { my $this = shift; foreach my $d (@_) { next unless defined $d and length $d; Carp::croak "\"$d\" isn't a valid directive name" unless $d =~ m/^[a-zA-Z][a-zA-Z0-9]*$/s; Carp::croak "But you must accept \"$d\" directives -- it's a builtin!" if exists $Known_directives{$d}; delete $this->{'accept_directives'}{$d}; DEBUG > 2 and print "OK, won't accept \"=$d\" as directive.\n"; } return sort keys %{ $this->{'accept_directives'} } if wantarray; return } #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ # # And now targets (not directives) sub accept_target { shift->accept_targets(@_) } # alias sub accept_target_as_text { shift->accept_targets_as_text(@_) } # alias sub accept_targets { shift->_accept_targets('1', @_) } sub accept_targets_as_text { shift->_accept_targets('force_resolve', @_) } # forces them to be processed, even when there's no ":". sub _accept_targets { my($this, $type) = splice @_,0,2; foreach my $t (@_) { next unless defined $t and length $t; # TODO: enforce some limitations on what a target name can be? $this->{'accept_targets'}{$t} = $type; DEBUG > 2 and print "Learning to accept \"$t\" as target of type $type\n"; } return sort keys %{ $this->{'accept_targets'} } if wantarray; return; } #-------------------------------------------------------------------------- sub unaccept_target { shift->unaccept_targets(@_) } sub unaccept_targets { my $this = shift; foreach my $t (@_) { next unless defined $t and length $t; # TODO: enforce some limitations on what a target name can be? delete $this->{'accept_targets'}{$t}; DEBUG > 2 and print "OK, won't accept \"$t\" as target.\n"; } return sort keys %{ $this->{'accept_targets'} } if wantarray; return; } #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ # # And now codes (not targets or directives) sub accept_code { shift->accept_codes(@_) } # alias sub accept_codes { # Add some codes my $this = shift; foreach my $new_code (@_) { next unless defined $new_code and length $new_code; if(ASCII) { # A good-enough check that it's good as an XML Name symbol: Carp::croak "\"$new_code\" isn't a valid element name" if $new_code =~ m/[\x00-\x2C\x2F\x39\x3B-\x40\x5B-\x5E\x60\x7B-\x7F]/ # Characters under 0x80 that aren't legal in an XML Name. or $new_code =~ m/^[-\.0-9]/s or $new_code =~ m/:[-\.0-9]/s; # The legal under-0x80 Name characters that # an XML Name still can't start with. } $this->{'accept_codes'}{$new_code} = $new_code; # Yes, map to itself -- just so that when we # see "=extend W [whatever] thatelementname", we say that W maps # to whatever $this->{accept_codes}{thatelementname} is, # i.e., "thatelementname". Then when we go re-mapping, # a "W" in the treelet turns into "thatelementname". We only # remap once. # If we say we accept "W", then a "W" in the treelet simply turns # into "W". } return; } #-------------------------------------------------------------------------- sub unaccept_code { shift->unaccept_codes(@_) } sub unaccept_codes { # remove some codes my $this = shift; foreach my $new_code (@_) { next unless defined $new_code and length $new_code; if(ASCII) { # A good-enough check that it's good as an XML Name symbol: Carp::croak "\"$new_code\" isn't a valid element name" if $new_code =~ m/[\x00-\x2C\x2F\x39\x3B-\x40\x5B-\x5E\x60\x7B-\x7F]/ # Characters under 0x80 that aren't legal in an XML Name. or $new_code =~ m/^[-\.0-9]/s or $new_code =~ m/:[-\.0-9]/s; # The legal under-0x80 Name characters that # an XML Name still can't start with. } Carp::croak "But you must accept \"$new_code\" codes -- it's a builtin!" if grep $new_code eq $_, @Known_formatting_codes; delete $this->{'accept_codes'}{$new_code}; DEBUG > 2 and print "OK, won't accept the code $new_code<...>.\n"; } return; } #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ sub parse_string_document { my $self = shift; my @lines; foreach my $line_group (@_) { next unless defined $line_group and length $line_group; pos($line_group) = 0; while($line_group =~ m/([^\n\r]*)(\r?\n?)/g # supports \r, \n ,\r\n #m/([^\n\r]*)((?:\r?\n)?)/g ) { #print(">> $1\n"), $self->parse_lines($1) if length($1) or length($2) or pos($line_group) != length($line_group); # I.e., unless it's a zero-length "empty line" at the very # end of "foo\nbar\n" (i.e., between the \n and the EOS). } } $self->parse_lines(undef); # to signal EOF return $self; } sub _init_fh_source { my($self, $source) = @_; #DEBUG > 1 and print "Declaring $source as :raw for starters\n"; #$self->_apply_binmode($source, ':raw'); #binmode($source, ":raw"); return; } #:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:. # sub parse_file { my($self, $source) = (@_); if(!defined $source) { Carp::croak("Can't use empty-string as a source for parse_file"); } elsif(ref(\$source) eq 'GLOB') { $self->{'source_filename'} = '' . ($source); } elsif(ref $source) { $self->{'source_filename'} = '' . ($source); } elsif(!length $source) { Carp::croak("Can't use empty-string as a source for parse_file"); } else { { local *PODSOURCE; open(PODSOURCE, "<$source") || Carp::croak("Can't open $source: $!"); $self->{'source_filename'} = $source; $source = *PODSOURCE{IO}; } $self->_init_fh_source($source); } # By here, $source is a FH. $self->{'source_fh'} = $source; my($i, @lines); until( $self->{'source_dead'} ) { splice @lines; for($i = MANY_LINES; $i--;) { # read those many lines at a time local $/ = $NL; push @lines, scalar(<$source>); # readline last unless defined $lines[-1]; # but pass thru the undef, which will set source_dead to true } my $at_eof = ! $lines[-1]; # keep track of the undef pop @lines if $at_eof; # silence warnings # be eol agnostic s/\r\n?/\n/g for @lines; # make sure there are only one line elements for parse_lines @lines = split(/(?<=\n)/, join('', @lines)); # push the undef back after popping it to set source_dead to true push @lines, undef if $at_eof; $self->parse_lines(@lines); } delete($self->{'source_fh'}); # so it can be GC'd return $self; } #:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:. sub parse_from_file { # An emulation of Pod::Parser's interface, for the sake of Perldoc. # Basically just a wrapper around parse_file. my($self, $source, $to) = @_; $self = $self->new unless ref($self); # so we tolerate being a class method if(!defined $source) { $source = *STDIN{IO} } elsif(ref(\$source) eq 'GLOB') { # stet } elsif(ref($source) ) { # stet } elsif(!length $source or $source eq '-' or $source =~ m/^<&(STDIN|0)$/i ) { $source = *STDIN{IO}; } if(!defined $to) { $self->output_fh( *STDOUT{IO} ); } elsif(ref(\$to) eq 'GLOB') { $self->output_fh( $to ); } elsif(ref($to)) { $self->output_fh( $to ); } elsif(!length $to or $to eq '-' or $to =~ m/^>&?(?:STDOUT|1)$/i ) { $self->output_fh( *STDOUT{IO} ); } else { require Symbol; my $out_fh = Symbol::gensym(); DEBUG and print "Write-opening to $to\n"; open($out_fh, ">$to") or Carp::croak "Can't write-open $to: $!"; binmode($out_fh) if $self->can('write_with_binmode') and $self->write_with_binmode; $self->output_fh($out_fh); } return $self->parse_file($source); } #----------------------------------------------------------------------------- sub whine { #my($self,$line,$complaint) = @_; my $self = shift(@_); ++$self->{'errors_seen'}; if($self->{'no_whining'}) { DEBUG > 9 and print "Discarding complaint (at line $_[0]) $_[1]\n because no_whining is on.\n"; return; } return $self->_complain_warn(@_) if $self->{'complain_stderr'}; return $self->_complain_errata(@_); } sub scream { # like whine, but not suppressible #my($self,$line,$complaint) = @_; my $self = shift(@_); ++$self->{'errors_seen'}; return $self->_complain_warn(@_) if $self->{'complain_stderr'}; return $self->_complain_errata(@_); } sub _complain_warn { my($self,$line,$complaint) = @_; return printf STDERR "%s around line %s: %s\n", $self->{'source_filename'} || 'Pod input', $line, $complaint; } sub _complain_errata { my($self,$line,$complaint) = @_; if( $self->{'no_errata_section'} ) { DEBUG > 9 and print "Discarding erratum (at line $line) $complaint\n because no_errata_section is on.\n"; } else { DEBUG > 9 and print "Queuing erratum (at line $line) $complaint\n"; push @{$self->{'errata'}{$line}}, $complaint # for a report to be generated later! } return 1; } #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ sub _get_initial_item_type { # A hack-wrapper here for when you have like "=over\n\n=item 456\n\n" my($self, $para) = @_; return $para->[1]{'~type'} if $para->[1]{'~type'}; return $para->[1]{'~type'} = 'text' if join("\n", @{$para}[2 .. $#$para]) =~ m/^\s*(\d+)\.?\s*$/s and $1 ne '1'; # Else fall thru to the general case: return $self->_get_item_type($para); } sub _get_item_type { # mutates the item!! my($self, $para) = @_; return $para->[1]{'~type'} if $para->[1]{'~type'}; # Otherwise we haven't yet been to this node. Maybe alter it... my $content = join "\n", @{$para}[2 .. $#$para]; if($content =~ m/^\s*\*\s*$/s or $content =~ m/^\s*$/s) { # Like: "=item *", "=item * ", "=item" splice @$para, 2; # so it ends up just being ['=item', { attrhash } ] $para->[1]{'~orig_content'} = $content; return $para->[1]{'~type'} = 'bullet'; } elsif($content =~ m/^\s*\*\s+(.+)/s) { # tolerance # Like: "=item * Foo bar baz"; $para->[1]{'~orig_content'} = $content; $para->[1]{'~_freaky_para_hack'} = $1; DEBUG > 2 and print " Tolerating $$para[2] as =item *\\n\\n$1\n"; splice @$para, 2; # so it ends up just being ['=item', { attrhash } ] return $para->[1]{'~type'} = 'bullet'; } elsif($content =~ m/^\s*(\d+)\.?\s*$/s) { # Like: "=item 1.", "=item 123412" $para->[1]{'~orig_content'} = $content; $para->[1]{'number'} = $1; # Yes, stores the number there! splice @$para, 2; # so it ends up just being ['=item', { attrhash } ] return $para->[1]{'~type'} = 'number'; } else { # It's anything else. return $para->[1]{'~type'} = 'text'; } } #----------------------------------------------------------------------------- sub _make_treelet { my $self = shift; # and ($para, $start_line) my $treelet; if(!@_) { return ['']; } if(ref $_[0] and ref $_[0][0] and $_[0][0][0] eq '~Top') { # Hack so we can pass in fake-o pre-cooked paragraphs: # just have the first line be a reference to a ['~Top', {}, ...] # We use this feechure in gen_errata and stuff. DEBUG and print "Applying precooked treelet hack to $_[0][0]\n"; $treelet = $_[0][0]; splice @$treelet, 0, 2; # lop the top off return $treelet; } else { $treelet = $self->_treelet_from_formatting_codes(@_); } if( $self->_remap_sequences($treelet) ) { $self->_treat_Zs($treelet); # Might as well nix these first $self->_treat_Ls($treelet); # L has to precede E and S $self->_treat_Es($treelet); $self->_treat_Ss($treelet); # S has to come after E $self->_wrap_up($treelet); # Nix X's and merge texties } else { DEBUG and print "Formatless treelet gets fast-tracked.\n"; # Very common case! } splice @$treelet, 0, 2; # lop the top off return $treelet; } #:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:. sub _wrap_up { my($self, @stack) = @_; my $nixx = $self->{'nix_X_codes'}; my $merge = $self->{'merge_text' }; return unless $nixx or $merge; DEBUG > 2 and print "\nStarting _wrap_up traversal.\n", $merge ? (" Merge mode on\n") : (), $nixx ? (" Nix-X mode on\n") : (), ; my($i, $treelet); while($treelet = shift @stack) { DEBUG > 3 and print " Considering children of this $treelet->[0] node...\n"; for($i = 2; $i < @$treelet; ++$i) { # iterate over children DEBUG > 3 and print " Considering child at $i ", pretty($treelet->[$i]), "\n"; if($nixx and ref $treelet->[$i] and $treelet->[$i][0] eq 'X') { DEBUG > 3 and print " Nixing X node at $i\n"; splice(@$treelet, $i, 1); # just nix this node (and its descendants) # no need to back-update the counter just yet redo; } elsif($merge and $i != 2 and # non-initial !ref $treelet->[$i] and !ref $treelet->[$i - 1] ) { DEBUG > 3 and print " Merging ", $i-1, ":[$treelet->[$i-1]] and $i\:[$treelet->[$i]]\n"; $treelet->[$i-1] .= ( splice(@$treelet, $i, 1) )[0]; DEBUG > 4 and print " Now: ", $i-1, ":[$treelet->[$i-1]]\n"; --$i; next; # since we just pulled the possibly last node out from under # ourselves, we can't just redo() } elsif( ref $treelet->[$i] ) { DEBUG > 4 and print " Enqueuing ", pretty($treelet->[$i]), " for traversal.\n"; push @stack, $treelet->[$i]; if($treelet->[$i][0] eq 'L') { my $thing; foreach my $attrname ('section', 'to') { if(defined($thing = $treelet->[$i][1]{$attrname}) and ref $thing) { unshift @stack, $thing; DEBUG > 4 and print " +Enqueuing ", pretty( $treelet->[$i][1]{$attrname} ), " as an attribute value to tweak.\n"; } } } } } } DEBUG > 2 and print "End of _wrap_up traversal.\n\n"; return; } #:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:. sub _remap_sequences { my($self,@stack) = @_; if(@stack == 1 and @{ $stack[0] } == 3 and !ref $stack[0][2]) { # VERY common case: abort it. DEBUG and print "Skipping _remap_sequences: formatless treelet.\n"; return 0; } my $map = ($self->{'accept_codes'} || die "NO accept_codes in $self?!?"); my $start_line = $stack[0][1]{'start_line'}; DEBUG > 2 and printf "\nAbout to start _remap_sequences on treelet from line %s.\n", $start_line || '[?]' ; DEBUG > 3 and print " Map: ", join('; ', map "$_=" . ( ref($map->{$_}) ? join(",", @{$map->{$_}}) : $map->{$_} ), sort keys %$map ), ("B~C~E~F~I~L~S~X~Z" eq join '~', sort keys %$map) ? " (all normal)\n" : "\n" ; # A recursive algorithm implemented iteratively! Whee! my($is, $was, $i, $treelet); # scratch while($treelet = shift @stack) { DEBUG > 3 and print " Considering children of this $treelet->[0] node...\n"; for($i = 2; $i < @$treelet; ++$i) { # iterate over children next unless ref $treelet->[$i]; # text nodes are uninteresting DEBUG > 4 and print " Noting child $i : $treelet->[$i][0]<...>\n"; $is = $treelet->[$i][0] = $map->{ $was = $treelet->[$i][0] }; if( DEBUG > 3 ) { if(!defined $is) { print " Code $was<> is UNKNOWN!\n"; } elsif($is eq $was) { DEBUG > 4 and print " Code $was<> stays the same.\n"; } else { print " Code $was<> maps to ", ref($is) ? ( "tags ", map("$_<", @$is), '...', map('>', @$is), "\n" ) : "tag $is<...>.\n"; } } if(!defined $is) { $self->whine($start_line, "Deleting unknown formatting code $was<>"); $is = $treelet->[$i][0] = '1'; # But saving the children! # I could also insert a leading "$was<" and tailing ">" as # children of this node, but something about that seems icky. } if(ref $is) { my @dynasty = @$is; DEBUG > 4 and print " Renaming $was node to $dynasty[-1]\n"; $treelet->[$i][0] = pop @dynasty; my $nugget; while(@dynasty) { DEBUG > 4 and printf " Grafting a new %s node between %s and %s\n", $dynasty[-1], $treelet->[0], $treelet->[$i][0], ; #$nugget = ; splice @$treelet, $i, 1, [pop(@dynasty), {}, $treelet->[$i]]; # relace node with a new parent } } elsif($is eq '0') { splice(@$treelet, $i, 1); # just nix this node (and its descendants) --$i; # back-update the counter } elsif($is eq '1') { splice(@$treelet, $i, 1 # replace this node with its children! => splice @{ $treelet->[$i] },2 # (not catching its first two (non-child) items) ); --$i; # back up for new stuff } else { # otherwise it's unremarkable unshift @stack, $treelet->[$i]; # just recurse } } } DEBUG > 2 and print "End of _remap_sequences traversal.\n\n"; if(@_ == 2 and @{ $_[1] } == 3 and !ref $_[1][2]) { DEBUG and print "Noting that the treelet is now formatless.\n"; return 0; } return 1; } # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . sub _ponder_extend { # "Go to an extreme, move back to a more comfortable place" # -- /Oblique Strategies/, Brian Eno and Peter Schmidt my($self, $para) = @_; my $content = join ' ', splice @$para, 2; $content =~ s/^\s+//s; $content =~ s/\s+$//s; DEBUG > 2 and print "Ogling extensor: =extend $content\n"; if($content =~ m/^ (\S+) # 1 : new item \s+ (\S+) # 2 : fallback(s) (?:\s+(\S+))? # 3 : element name(s) \s* $ /xs ) { my $new_letter = $1; my $fallbacks_one = $2; my $elements_one; $elements_one = defined($3) ? $3 : $1; DEBUG > 2 and print "Extensor has good syntax.\n"; unless($new_letter =~ m/^[A-Z]$/s or $new_letter) { DEBUG > 2 and print " $new_letter isn't a valid thing to entend.\n"; $self->whine( $para->[1]{'start_line'}, "You can extend only formatting codes A-Z, not like \"$new_letter\"" ); return; } if(grep $new_letter eq $_, @Known_formatting_codes) { DEBUG > 2 and print " $new_letter isn't a good thing to extend, because known.\n"; $self->whine( $para->[1]{'start_line'}, "You can't extend an established code like \"$new_letter\"" ); #TODO: or allow if last bit is same? return; } unless($fallbacks_one =~ m/^[A-Z](,[A-Z])*$/s # like "B", "M,I", etc. or $fallbacks_one eq '0' or $fallbacks_one eq '1' ) { $self->whine( $para->[1]{'start_line'}, "Format for second =extend parameter must be like" . " M or 1 or 0 or M,N or M,N,O but you have it like " . $fallbacks_one ); return; } unless($elements_one =~ m/^[^ ,]+(,[^ ,]+)*$/s) { # like "B", "M,I", etc. $self->whine( $para->[1]{'start_line'}, "Format for third =extend parameter: like foo or bar,Baz,qu:ux but not like " . $elements_one ); return; } my @fallbacks = split ',', $fallbacks_one, -1; my @elements = split ',', $elements_one, -1; foreach my $f (@fallbacks) { next if exists $Known_formatting_codes{$f} or $f eq '0' or $f eq '1'; DEBUG > 2 and print " Can't fall back on unknown code $f\n"; $self->whine( $para->[1]{'start_line'}, "Can't use unknown formatting code '$f' as a fallback for '$new_letter'" ); return; } DEBUG > 3 and printf "Extensor: Fallbacks <%s> Elements <%s>.\n", @fallbacks, @elements; my $canonical_form; foreach my $e (@elements) { if(exists $self->{'accept_codes'}{$e}) { DEBUG > 1 and print " Mapping '$new_letter' to known extension '$e'\n"; $canonical_form = $e; last; # first acceptable elementname wins! } else { DEBUG > 1 and print " Can't map '$new_letter' to unknown extension '$e'\n"; } } if( defined $canonical_form ) { # We found a good N => elementname mapping $self->{'accept_codes'}{$new_letter} = $canonical_form; DEBUG > 2 and print "Extensor maps $new_letter => known element $canonical_form.\n"; } else { # We have to use the fallback(s), which might be '0', or '1'. $self->{'accept_codes'}{$new_letter} = (@fallbacks == 1) ? $fallbacks[0] : \@fallbacks; DEBUG > 2 and print "Extensor maps $new_letter => fallbacks @fallbacks.\n"; } } else { DEBUG > 2 and print "Extensor has bad syntax.\n"; $self->whine( $para->[1]{'start_line'}, "Unknown =extend syntax: $content" ) } return; } #:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:. sub _treat_Zs { # Nix Z<...>'s my($self,@stack) = @_; my($i, $treelet); my $start_line = $stack[0][1]{'start_line'}; # A recursive algorithm implemented iteratively! Whee! while($treelet = shift @stack) { for($i = 2; $i < @$treelet; ++$i) { # iterate over children next unless ref $treelet->[$i]; # text nodes are uninteresting unless($treelet->[$i][0] eq 'Z') { unshift @stack, $treelet->[$i]; # recurse next; } DEBUG > 1 and print "Nixing Z node @{$treelet->[$i]}\n"; # bitch UNLESS it's empty unless( @{$treelet->[$i]} == 2 or (@{$treelet->[$i]} == 3 and $treelet->[$i][2] eq '') ) { $self->whine( $start_line, "A non-empty Z<>" ); } # but kill it anyway splice(@$treelet, $i, 1); # thereby just nix this node. --$i; } } return; } # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # Quoting perlpodspec: # In parsing an L<...> code, Pod parsers must distinguish at least four # attributes: ############# Not used. Expressed via the element children plus ############# the value of the "content-implicit" flag. # First: # The link-text. If there is none, this must be undef. (E.g., in "L", the link-text is "Perl Functions". In # "L" and even "L<|Time::HiRes>", there is no link text. Note # that link text may contain formatting.) # ############# The element children # Second: # The possibly inferred link-text -- i.e., if there was no real link text, # then this is the text that we'll infer in its place. (E.g., for # "L", the inferred link text is "Getopt::Std".) # ############# The "to" attribute (which might be text, or a treelet) # Third: # The name or URL, or undef if none. (E.g., in "L", the name -- also sometimes called the page -- is # "perlfunc". In "L", the name is undef.) # ############# The "section" attribute (which might be next, or a treelet) # Fourth: # The section (AKA "item" in older perlpods), or undef if none. E.g., in # Getopt::Std/DESCRIPTION, "DESCRIPTION" is the section. (Note that this # is not the same as a manpage section like the "5" in "man 5 crontab". # "Section Foo" in the Pod sense means the part of the text that's # introduced by the heading or item whose text is "Foo".) # # Pod parsers may also note additional attributes including: # ############# The "type" attribute. # Fifth: # A flag for whether item 3 (if present) is a URL (like # "http://lists.perl.org" is), in which case there should be no section # attribute; a Pod name (like "perldoc" and "Getopt::Std" are); or # possibly a man page name (like "crontab(5)" is). # ############# The "raw" attribute that is already there. # Sixth: # The raw original L<...> content, before text is split on "|", "/", etc, # and before E<...> codes are expanded. # For L<...> codes without a "name|" part, only E<...> and Z<> codes may # occur -- no other formatting codes. That is, authors should not use # "L>". # # Note, however, that formatting codes and Z<>'s can occur in any and all # parts of an L<...> (i.e., in name, section, text, and url). sub _treat_Ls { # Process our dear dear friends, the L<...> sequences # L # L or L # L or L or L<"sec"> # L # L or L # L or L or L # L # L my($self,@stack) = @_; my($i, $treelet); my $start_line = $stack[0][1]{'start_line'}; # A recursive algorithm implemented iteratively! Whee! while($treelet = shift @stack) { for(my $i = 2; $i < @$treelet; ++$i) { # iterate over children of current tree node next unless ref $treelet->[$i]; # text nodes are uninteresting unless($treelet->[$i][0] eq 'L') { unshift @stack, $treelet->[$i]; # recurse next; } # By here, $treelet->[$i] is definitely an L node my $ell = $treelet->[$i]; DEBUG > 1 and print "Ogling L node $ell\n"; # bitch if it's empty if( @{$ell} == 2 or (@{$ell} == 3 and $ell->[2] eq '') ) { $self->whine( $start_line, "An empty L<>" ); $treelet->[$i] = 'L<>'; # just make it a text node next; # and move on } # Catch URLs: # there are a number of possible cases: # 1) text node containing url: http://foo.com # -> [ 'http://foo.com' ] # 2) text node containing url and text: foo|http://foo.com # -> [ 'foo|http://foo.com' ] # 3) text node containing url start: mailto:xEfoo.com # -> [ 'mailto:x', [ E ... ], 'foo.com' ] # 4) text node containing url start and text: foo|mailto:xEfoo.com # -> [ 'foo|mailto:x', [ E ... ], 'foo.com' ] # 5) other nodes containing text and url start: OE<39>Malley|http://foo.com # -> [ 'O', [ E ... ], 'Malley', '|http://foo.com' ] # ... etc. # anything before the url is part of the text. # anything after it is part of the url. # the url text node itself may contain parts of both. if (my ($url_index, $text_part, $url_part) = # grep is no good here; we want to bail out immediately so that we can # use $1, $2, etc. without having to do the match twice. sub { for (2..$#$ell) { next if ref $ell->[$_]; next unless $ell->[$_] =~ m/^(?:([^|]*)\|)?(\w+:[^:\s]\S*)$/s; return ($_, $1, $2); } return; }->() ) { $ell->[1]{'type'} = 'url'; my @text = @{$ell}[2..$url_index-1]; push @text, $text_part if defined $text_part; my @url = @{$ell}[$url_index+1..$#$ell]; unshift @url, $url_part; unless (@text) { $ell->[1]{'content-implicit'} = 'yes'; @text = @url; } $ell->[1]{to} = Pod::Simple::LinkSection->new( @url == 1 ? $url[0] : [ '', {}, @url ], ); splice @$ell, 2, $#$ell, @text; next; } # Catch some very simple and/or common cases if(@{$ell} == 3 and ! ref $ell->[2]) { my $it = $ell->[2]; if($it =~ m/^[-a-zA-Z0-9]+\([-a-zA-Z0-9]+\)$/s) { # man sections # Hopefully neither too broad nor too restrictive a RE DEBUG > 1 and print "Catching \"$it\" as manpage link.\n"; $ell->[1]{'type'} = 'man'; # This's the only place where man links can get made. $ell->[1]{'content-implicit'} = 'yes'; $ell->[1]{'to' } = Pod::Simple::LinkSection->new( $it ); # treelet! next; } if($it =~ m/^[^\/\|,\$\%\@\ \"\<\>\:\#\&\*\{\}\[\]\(\)]+(\:\:[^\/\|,\$\%\@\ \"\<\>\:\#\&\*\{\}\[\]\(\)]+)*$/s) { # Extremely forgiving idea of what constitutes a bare # modulename link like L or even L DEBUG > 1 and print "Catching \"$it\" as ho-hum L link.\n"; $ell->[1]{'type'} = 'pod'; $ell->[1]{'content-implicit'} = 'yes'; $ell->[1]{'to' } = Pod::Simple::LinkSection->new( $it ); # treelet! next; } # else fall thru... } # ...Uhoh, here's the real L<...> parsing stuff... # "With the ill behavior, with the ill behavior, with the ill behavior..." DEBUG > 1 and print "Running a real parse on this non-trivial L\n"; my $link_text; # set to an arrayref if found my @ell_content = @$ell; splice @ell_content,0,2; # Knock off the 'L' and {} bits DEBUG > 3 and print " Ell content to start: ", pretty(@ell_content), "\n"; # Look for the "|" -- only in CHILDREN (not all underlings!) # Like L DEBUG > 3 and print " Peering at L content for a '|' ...\n"; for(my $j = 0; $j < @ell_content; ++$j) { next if ref $ell_content[$j]; DEBUG > 3 and print " Peering at L-content text bit \"$ell_content[$j]\" for a '|'.\n"; if($ell_content[$j] =~ m/^([^\|]*)\|(.*)$/s) { my @link_text = ($1); # might be 0-length $ell_content[$j] = $2; # might be 0-length DEBUG > 3 and print " FOUND a '|' in it. Splitting into [$1] + [$2]\n"; unshift @link_text, splice @ell_content, 0, $j; # leaving only things at J and after @ell_content = grep ref($_)||length($_), @ell_content ; $link_text = [grep ref($_)||length($_), @link_text ]; DEBUG > 3 and printf " So link text is %s\n and remaining ell content is %s\n", pretty($link_text), pretty(@ell_content); last; } } # Now look for the "/" -- only in CHILDREN (not all underlings!) # And afterward, anything left in @ell_content will be the raw name # Like L my $section_name; # set to arrayref if found DEBUG > 3 and print " Peering at L-content for a '/' ...\n"; for(my $j = 0; $j < @ell_content; ++$j) { next if ref $ell_content[$j]; DEBUG > 3 and print " Peering at L-content text bit \"$ell_content[$j]\" for a '/'.\n"; if($ell_content[$j] =~ m/^([^\/]*)\/(.*)$/s) { my @section_name = ($2); # might be 0-length $ell_content[$j] = $1; # might be 0-length DEBUG > 3 and print " FOUND a '/' in it.", " Splitting to page [...$1] + section [$2...]\n"; push @section_name, splice @ell_content, 1+$j; # leaving only things before and including J @ell_content = grep ref($_)||length($_), @ell_content ; @section_name = grep ref($_)||length($_), @section_name ; # Turn L<.../"foo"> into L<.../foo> if(@section_name and !ref($section_name[0]) and !ref($section_name[-1]) and $section_name[ 0] =~ m/^\"/s and $section_name[-1] =~ m/\"$/s and !( # catch weird degenerate case of L<"> ! @section_name == 1 and $section_name[0] eq '"' ) ) { $section_name[ 0] =~ s/^\"//s; $section_name[-1] =~ s/\"$//s; DEBUG > 3 and print " Quotes removed: ", pretty(@section_name), "\n"; } else { DEBUG > 3 and print " No need to remove quotes in ", pretty(@section_name), "\n"; } $section_name = \@section_name; last; } } # Turn L<"Foo Bar"> into L if(!$section_name and @ell_content and !ref($ell_content[0]) and !ref($ell_content[-1]) and $ell_content[ 0] =~ m/^\"/s and $ell_content[-1] =~ m/\"$/s and !( # catch weird degenerate case of L<"> ! @ell_content == 1 and $ell_content[0] eq '"' ) ) { $section_name = [splice @ell_content]; $section_name->[ 0] =~ s/^\"//s; $section_name->[-1] =~ s/\"$//s; } # Turn L into L. if(!$section_name and !$link_text and @ell_content and grep !ref($_) && m/ /s, @ell_content ) { $section_name = [splice @ell_content]; # That's support for the now-deprecated syntax. # (Maybe generate a warning eventually?) # Note that it deliberately won't work on L<...|Foo Bar> } # Now make up the link_text # L -> L # L -> L<"Bar"|Bar> # L -> L<"Bar" in Foo/Foo> unless($link_text) { $ell->[1]{'content-implicit'} = 'yes'; $link_text = []; push @$link_text, '"', @$section_name, '"' if $section_name; if(@ell_content) { $link_text->[-1] .= ' in ' if $section_name; push @$link_text, @ell_content; } } # And the E resolver will have to deal with all our treeletty things: if(@ell_content == 1 and !ref($ell_content[0]) and $ell_content[0] =~ m/^[-a-zA-Z0-9]+\([-a-zA-Z0-9]+\)$/s ) { $ell->[1]{'type'} = 'man'; DEBUG > 3 and print "Considering this ($ell_content[0]) a man link.\n"; } else { $ell->[1]{'type'} = 'pod'; DEBUG > 3 and print "Considering this a pod link (not man or url).\n"; } if( defined $section_name ) { $ell->[1]{'section'} = Pod::Simple::LinkSection->new( ['', {}, @$section_name] ); DEBUG > 3 and print "L-section content: ", pretty($ell->[1]{'section'}), "\n"; } if( @ell_content ) { $ell->[1]{'to'} = Pod::Simple::LinkSection->new( ['', {}, @ell_content] ); DEBUG > 3 and print "L-to content: ", pretty($ell->[1]{'to'}), "\n"; } # And update children to be the link-text: @$ell = (@$ell[0,1], defined($link_text) ? splice(@$link_text) : ''); DEBUG > 2 and print "End of L-parsing for this node $treelet->[$i]\n"; unshift @stack, $treelet->[$i]; # might as well recurse } } return; } # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . sub _treat_Es { my($self,@stack) = @_; my($i, $treelet, $content, $replacer, $charnum); my $start_line = $stack[0][1]{'start_line'}; # A recursive algorithm implemented iteratively! Whee! # Has frightening side effects on L nodes' attributes. #my @ells_to_tweak; while($treelet = shift @stack) { for(my $i = 2; $i < @$treelet; ++$i) { # iterate over children next unless ref $treelet->[$i]; # text nodes are uninteresting if($treelet->[$i][0] eq 'L') { # SPECIAL STUFF for semi-processed L<>'s my $thing; foreach my $attrname ('section', 'to') { if(defined($thing = $treelet->[$i][1]{$attrname}) and ref $thing) { unshift @stack, $thing; DEBUG > 2 and print " Enqueuing ", pretty( $treelet->[$i][1]{$attrname} ), " as an attribute value to tweak.\n"; } } unshift @stack, $treelet->[$i]; # recurse next; } elsif($treelet->[$i][0] ne 'E') { unshift @stack, $treelet->[$i]; # recurse next; } DEBUG > 1 and print "Ogling E node ", pretty($treelet->[$i]), "\n"; # bitch if it's empty if( @{$treelet->[$i]} == 2 or (@{$treelet->[$i]} == 3 and $treelet->[$i][2] eq '') ) { $self->whine( $start_line, "An empty E<>" ); $treelet->[$i] = 'E<>'; # splice in a literal next; } # bitch if content is weird unless(@{$treelet->[$i]} == 3 and !ref($content = $treelet->[$i][2])) { $self->whine( $start_line, "An E<...> surrounding strange content" ); $replacer = $treelet->[$i]; # scratch splice(@$treelet, $i, 1, # fake out a literal 'E<', splice(@$replacer,2), # promote its content '>' ); # Don't need to do --$i, as the 'E<' we just added isn't interesting. next; } DEBUG > 1 and print "Ogling E<$content>\n"; # XXX E<>'s contents *should* be a valid char in the scope of the current # =encoding directive. Defaults to iso-8859-1, I believe. Fix this in the # future sometime. $charnum = Pod::Escapes::e2charnum($content); DEBUG > 1 and print " Considering E<$content> with char ", defined($charnum) ? $charnum : "undef", ".\n"; if(!defined( $charnum )) { DEBUG > 1 and print "I don't know how to deal with E<$content>.\n"; $self->whine( $start_line, "Unknown E content in E<$content>" ); $replacer = "E<$content>"; # better than nothing } elsif($charnum >= 255 and !UNICODE) { $replacer = ASCII ? "\xA4" : "?"; DEBUG > 1 and print "This Perl version can't handle ", "E<$content> (chr $charnum), so replacing with $replacer\n"; } else { $replacer = Pod::Escapes::e2char($content); DEBUG > 1 and print " Replacing E<$content> with $replacer\n"; } splice(@$treelet, $i, 1, $replacer); # no need to back up $i, tho } } return; } # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . sub _treat_Ss { my($self,$treelet) = @_; _change_S_to_nbsp($treelet,0) if $self->{'nbsp_for_S'}; # TODO: or a change_nbsp_to_S # Normalizing nbsp's to S is harder: for each text node, make S content # out of anything matching m/([^ \xA0]*(?:\xA0+[^ \xA0]*)+)/ return; } sub _change_S_to_nbsp { # a recursive function # Sanely assumes that the top node in the excursion won't be an S node. my($treelet, $in_s) = @_; my $is_s = ('S' eq $treelet->[0]); $in_s ||= $is_s; # So in_s is on either by this being an S element, # or by an ancestor being an S element. for(my $i = 2; $i < @$treelet; ++$i) { if(ref $treelet->[$i]) { if( _change_S_to_nbsp( $treelet->[$i], $in_s ) ) { my $to_pull_up = $treelet->[$i]; splice @$to_pull_up,0,2; # ...leaving just its content splice @$treelet, $i, 1, @$to_pull_up; # Pull up content $i += @$to_pull_up - 1; # Make $i skip the pulled-up stuff } } else { $treelet->[$i] =~ s/\s/\xA0/g if ASCII and $in_s; # (If not in ASCIIland, we can't assume that \xA0 == nbsp.) # Note that if you apply nbsp_for_S to text, and so turn # "foo S quux" into "foo bar faz quux", you # end up with something that fails to say "and don't hyphenate # any part of 'bar baz'". However, hyphenation is such a vexing # problem anyway, that most Pod renderers just don't render it # at all. But if you do want to implement hyphenation, I guess # that you'd better have nbsp_for_S off. } } return $is_s; } #----------------------------------------------------------------------------- sub _accessorize { # A simple-minded method-maker no strict 'refs'; foreach my $attrname (@_) { next if $attrname =~ m/::/; # a hack *{caller() . '::' . $attrname} = sub { use strict; $Carp::CarpLevel = 1, Carp::croak( "Accessor usage: \$obj->$attrname() or \$obj->$attrname(\$new_value)" ) unless (@_ == 1 or @_ == 2) and ref $_[0]; (@_ == 1) ? $_[0]->{$attrname} : ($_[0]->{$attrname} = $_[1]); }; } # Ya know, they say accessories make the ensemble! return; } # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #============================================================================= sub filter { my($class, $source) = @_; my $new = $class->new; $new->output_fh(*STDOUT{IO}); if(ref($source || '') eq 'SCALAR') { $new->parse_string_document( $$source ); } elsif(ref($source)) { # it's a file handle $new->parse_file($source); } else { # it's a filename $new->parse_file($source); } return $new; } #----------------------------------------------------------------------------- sub _out { # For use in testing: Class->_out($source) # returns the transformation of $source my $class = shift(@_); my $mutor = shift(@_) if @_ and ref($_[0] || '') eq 'CODE'; DEBUG and print "\n\n", '#' x 76, "\nAbout to parse source: {{\n$_[0]\n}}\n\n"; my $parser = ref $class && $class->isa(__PACKAGE__) ? $class : $class->new; $parser->hide_line_numbers(1); my $out = ''; $parser->output_string( \$out ); DEBUG and print " _out to ", \$out, "\n"; $mutor->($parser) if $mutor; $parser->parse_string_document( $_[0] ); # use Data::Dumper; print Dumper($parser), "\n"; return $out; } sub _duo { # For use in testing: Class->_duo($source1, $source2) # returns the parse trees of $source1 and $source2. # Good in things like: &ok( Class->duo(... , ...) ); my $class = shift(@_); Carp::croak "But $class->_duo is useful only in list context!" unless wantarray; my $mutor = shift(@_) if @_ and ref($_[0] || '') eq 'CODE'; Carp::croak "But $class->_duo takes two parameters, not: @_" unless @_ == 2; my(@out); while( @_ ) { my $parser = $class->new; push @out, ''; $parser->output_string( \( $out[-1] ) ); DEBUG and print " _duo out to ", $parser->output_string(), " = $parser->{'output_string'}\n"; $parser->hide_line_numbers(1); $mutor->($parser) if $mutor; $parser->parse_string_document( shift( @_ ) ); # use Data::Dumper; print Dumper($parser), "\n"; } return @out; } #----------------------------------------------------------------------------- 1; __END__ TODO: A start_formatting_code and end_formatting_code methods, which in the base class call start_L, end_L, start_C, end_C, etc., if they are defined. have the POD FORMATTING ERRORS section note the localtime, and the version of Pod::Simple. option to delete all Es? option to scream if under-0x20 literals are found in the input, or under-E<32> E codes are found in the tree. And ditto \x7f-\x9f Option to turn highbit characters into their compromised form? (applies to E parsing too) TODO: BOM/encoding things. TODO: ascii-compat things in the XML classes?
|
__label__pos
| 0.994273 |
精子最近在开发一个「简单」的容器平台 DeployBeta，目前还在非常早期的阶段。
查看源代码
在 LeanCloud 中使用 GraphQL
GraphQL 是 FaceBook 开源的一套数据查询语言，也是 Relay 钦定的组件，可以在客户端以一种非常灵活的语法来获取数据，但目前支持 GraphQL 的服务还比较少，最近 GitHub 也宣布了其开放 API 支持了 GraphQL
因为 GraphQL 的支持需要服务器端的更改，因此我选择了在 LeanCloud 的数据服务的基础上用 Node.js 编写一个中间层，运行在云引擎上，将 GraphQL 的查询翻译成对 LeanCloud SDK 的调用，为客户端提供 GraphQL 支持。
我也参考了其他语言和框架的 GraphQL 支持，它们都需要开发者进行很多的开发或配置工作。这是因为无论在 MySQL 还是 MongoDB 中都并没有记录数据之间的关联关系（Id 和 ObjectId 都不会记录指向的表或集合，MySQL 的外键倒是会记录，但可惜用户不多）；而且即使你定义了数据之间的关联，你还是需要去定义权限 —— 哪些用户可以访问哪些数据。
而 LeanCloud 的 Relation 和 Pointer 都记录了所指向的 Class，同时 LeanCloud 本身也有一套基于 sessionToken 和 ACL 的权限控制机制，因此我们完全可以做到从 LeanCloud 的数据服务获取数据之间的管理，然后遵循现有的 ACL 来自动实现对 GraphQL 的支持。
leancloud-graphql 就是这样的一个项目，你只需将它部署到云引擎上，不需要改动一行代码，便可以用 GraphQL 查询你在 LeanCloud 上的所有数据。
相较于 RESTful 和 SQL，GraphQL 为数据定义了严格的类型，你可以使用这样一个灵活的语言将数据通过关系组合起来，所见即所得地得到你想要的数据。得益于 GraphQL 的类型系统，你还可以在调试工具（graphql.leanapp.cn）中得到精确的错误提示和补全建议。
例如这里我们查询 Todo 这个 Class 中按优先级排序的前两条数据，获取 title、priority，并将 owner 这个 Pointer 展开：
query {
Todo(ascending: priority, limit: 2) {
title, priority, owner {
username
}
}
}
结果：
{
Todo: [{
title: "紧急 Bug 修复",
priority: 0,
owner: {
username: "someone"
}
}, {
title: "打电话给 Peter",
priority: 5,
owner: {
username: "someone"
}
}]
}
目前 leancloud-graphql 已经实现了 LeanCloud 中大部分的查询参数和查询条件，你可以任意地组合这些条件。例如我们可以查询优先级大于 5 且存在 content 属性的数据：
query {
Todo(exists: {content: true}, greaterThan: {priority: 5}) {
title, content, priority
}
}
GraphQL 最大的亮点还是对关系查询的支持，无论是 Relation 还是 Pointer 你都可以任意地展开，而不必受到 LeanCloud RESTful API 只能展开一层的限制。例如我们查询所有的 TodoFolder 中的 Todo（Relation）并展开 owner（Pointer）：
query {
TodoFolder {
name,
containedTodos {
title, owner {
username, email
}
}
}
}
结果（省略了一部分）：
{
TodoFolder: [{
name: "工作",
containedTodos: [{
title: "紧急 Bug 修复",
owner: {
username: "someone",
email: "[email protected]"
}
}, // ...
]
}, // ...
]
}
你也可以在关系查询上附加查询参数或条件。例如我们查询所有 TodoFolder 中优先级最高的一个 Todo：
query {
TodoFolder {
name, containedTodos(limit: 1, ascending: priority) {
title, priority
}
}
}
结果：
{
TodoFolder: [{
name: "工作",
containedTodos: [
{title: "紧急 Bug 修复", priority: 0}
]
},
name: "购物清单",
containedTodos: [
{title: "买酸奶", priority: 10}
]
}, {
name: "someone",
containedTodos: [
{title: "紧急 Bug 修复", priority: 0}
]
}]
}
在实现一对多关系时，我们经常会在「多」上面保存一个到「一」的指针，例如一个 Todo 会有一个叫 owner 的 Pointer 指向用户表。在这时，leancloud-graphql 会自动在用户表上添加一个叫 ownerOfTodo 的属性用来表示这个反向关系，你可以像展开一个 Relation 一样展开这个反向关系，例如我们查询每个用户的 Todo 并展开 title：
query {
_User {
username, ownerOfTodo {
title
}
}
}
结果：
{
_User: [{
username: "someone",
ownerOfTodo: [
{title: "紧急 Bug 修复"},
{title: "打电话给 Peter"},
{title: "还信用卡账单"},
{title: "买酸奶"}
]
}]
}
leancloud-graphql 的简单介绍就到这里，更多使用方法和功能介绍可以在项目的 GitHub 主页上看到，这个项目本身也是开源的。
撰写评论
精子写了这么多年博客，收到的优秀评论少之又少，在这个属于 SNS 的时代也并不缺少向作者反馈的渠道。因此如果你希望撰写评论，请发邮件至 [email protected] 并注明文章标题，我会挑选对读者有价值的评论附加到文章末尾。
精子生于 1995.11.25, 21 岁，英文 ID jysperm.
订阅推送
通过邮件订阅精子的博客日志、产品和项目的最新动态，精子承诺每一封邮件都会认真撰写（历史邮件），有想和精子说的话也可以直接回复邮件。
该博客使用基于 Hexo 的 simpleblock 主题。博客内容使用 CC BY-NC-SA 3.0 授权发布。最后生成于 2019-01-14.
|
__label__pos
| 0.998711 |
What is the percentage increase/decrease from 11 to 3072?
Quickly work out the percentage increase or decrease from 11 to 3072 in this step-by-step percentage calculator tutorial. (Spoiler alert: it's 27827.27%!)
So you want to work out the percentage increase or decrease from 11 to 3072? Fear not, intrepid math seeker! Today, we will guide you through the calculation so you can figure out how to work out the increase or decrease in any numbers as a percentage. Onwards!
In a rush and just need to know the answer? The percentage increase from 11 to 3072 is 27827.27%.
What is the % change from to
Percentage increase/decrease from 11 to 3072?
An increase or decrease percentage of two numbers can be very useful. Let's say you are a shop that sold 11 t-shirts in January, and then sold 3072 t-shirts in February. What is the percentage increase or decrease there? Knowing the answer allows you to compare and track numbers to look for trends or reasons for the change.
Working out a percentage increase or decrease between two numbers is pretty simple. The resulting number (the second input) is 3072 and what we need to do first is subtract the old number, 11, from it:
3072 - 11 = 3061
Once we've done that we need to divide the result, 3061, by the original number, 11. We do this because we need to compare the difference between the new number and the original:
3061 / 11 = 278.27272727273
We now have our answer in decimal format. How do we get this into percentage format? Multiply 278.27272727273 by 100? Ding ding ding! We have a winner:
278.27272727273 x 100 = 27827.27%
We're done! You just successfully calculated the percentage difference from 11 to 3072. You can now go forth and use this method to work out and calculate the increase/decrease in percentage of any numbers.
Head back to the percentage calculator to work out any more calculations you need to make or be brave and give it a go by hand. Hopefully this article has shown you that it's easier than you might think!
|
__label__pos
| 0.989201 |
[Twisted-Python] Problem Reading a Directory with Conch/SFTP
Jeffrey Ollie jeff at ocjtech.us
Mon Aug 22 16:02:25 EDT 2011
I'm re-writing a client that downloads some data from a 3rd party
using SFTP. The old client was written using Paramiko but I'd like to
rewrite it using Twisted and Conch. Right now I'm running into an
issue trying to get a directory listing from the remote server:
2011-08-22 13:35:03-0500 [SSHChannel session (0) on SSHService
ssh-connection on _WrappingProtocol,client] Unhandled Error
Traceback (most recent call last):
File "/usr/lib64/python2.7/site-packages/twisted/python/log.py",
line 84, in callWithLogger
return callWithContext({"system": lp}, func, *args, **kw)
File "/usr/lib64/python2.7/site-packages/twisted/python/log.py",
line 69, in callWithContext
return context.call({ILogContext: newCtx}, func, *args, **kw)
File "/usr/lib64/python2.7/site-packages/twisted/python/context.py",
line 118, in callWithContext
return self.currentContext().callWithContext(ctx, func, *args, **kw)
File "/usr/lib64/python2.7/site-packages/twisted/python/context.py",
line 81, in callWithContext
return func(*args,**kw)
--- <exception caught here> ---
File "/usr/lib64/python2.7/site-packages/twisted/conch/ssh/filetransfer.py",
line 53, in dataReceived
f(data)
File "/usr/lib64/python2.7/site-packages/twisted/conch/ssh/filetransfer.py",
line 711, in packet_STATUS
msg, data = getNS(data)
File "/usr/lib64/python2.7/site-packages/twisted/conch/ssh/common.py",
line 36, in getNS
l, = struct.unpack('!L',s[c:c+4])
struct.error: unpack requires a string argument of length 4
The problem seems to be that the remote SFTP implementation isn't
returning complete status response message - it doesn't include the
error message and the language identifier. I made a quite ugly
workaround:
diff --git a/twisted/conch/ssh/filetransfer.py b/twisted/conch/ssh/filetransfer.
index 81a86fd..ed55b27 100644
--- a/twisted/conch/ssh/filetransfer.py
+++ b/twisted/conch/ssh/filetransfer.py
@@ -708,8 +708,15 @@ class FileTransferClient(FileTransferBase):
d, data = self._parseRequest(data)
code, = struct.unpack('!L', data[:4])
data = data[4:]
- msg, data = getNS(data)
- lang = getNS(data)
+ if len(data) >= 4:
+ msg, data = getNS(data)
+ if len(data) >= 4:
+ lang = getNS(data)
+ else:
+ lang = ''
+ else:
+ msg = ''
+ lang = ''
if code == FX_OK:
d.callback((msg, lang))
elif code == FX_EOF:
Looking through the Paramiko code[1] it looks like it pads SFTP
messages that are shorter than expected with null bytes. From what I
saw in the SFTP I-D[2], a status message that doesn't include the
error message and language code could be construed as legal even
though they are not specifically marked as optional.
[1] https://github.com/robey/paramiko/blob/master/paramiko/message.py#L103
[2] http://tools.ietf.org/html/draft-ietf-secsh-filexfer-13#section-4
--
Jeff Ollie
More information about the Twisted-Python mailing list
|
__label__pos
| 0.697813 |
When is a function equal to its Fourier series?
• Thread starter kloptok
• Start date
• #1
188
0
Main Question or Discussion Point
When is a function "equal to" its Fourier series?
First of all - a bit unsure where this post fits in, there seems to be no immediately appropriate subforum.
So I'm a physics student and currently looking at what it takes for a Fourier series to converge. I've looked at wiki (http://en.wikipedia.org/wiki/Convergence_of_Fourier_series ) and this probably should tell me everything I need to know, if i only were fluent in the language of convergence. I don't really know the significance of the different types of convergence (uniform, pointwise etc.) and since I'm a physicist I suspect that this might not be of very much importance since we usually assume all functions are "nice" in physics ("nice" being the appropriate simplification in the problem at hand). I vaguely remember something about L^2 functions being important for this stuff - does this have any significance? Something to compare with is perhaps analytic functions and Taylor series - what would be the analog of analytic functions in the case of Fourier series?
So what I'm asking is: when is a function "equal to" its Fourier series? Is "equal to" the same as some form of convergence? Are there "analytic functions" for Fourier series?
What I'm interested in is if there is some simple criteria which will almost always be satisfied for problems in physics. Please be gentle with me, I have forgotten a lot of this stuff and I know I'm far from an expert. :shy:
Answers and Replies
• #2
jbunniii
Science Advisor
Homework Helper
Insights Author
Gold Member
3,394
180
There are several ways in which a function can "equal" its Fourier series. The simplest is pointwise convergence. This means that the following equality holds for all [itex]x[/itex]:
[tex]f(x) = \sum_n a_n e^{i2\pi n x/T}[/tex]
where [itex]a_n[/itex] is the [itex]n[/itex]'th Fourier coefficient and [itex]T[/itex] is the period of [itex]f[/itex]. In other words, for any [itex]x[/itex], the series converges to the value [itex]f(x)[/itex].
When working in spaces such as [itex]L^1[/itex] or [itex]L^2[/itex], it is no longer possible to talk about pointwise convergence. Indeed, the elements of these spaces not functions at all, but equivalence classes of functions. Two functions are considered one and the same if they differ only on a set of measure zero. A set of measure zero can be infinite, and even uncountably infinite (e.g. Cantor set), so the functions can be quite different pointwise and yet still considered "the same" in these spaces. So, pointwise convergence is replaced by "almost everywhere" convergence, meaning that the above equality holds except possibly on a set of measure zero.
There are other useful notions of convergence in these spaces, notably convergence in the norm. For example, in [itex]L^1[/itex], the norm of a function [itex]f \in L^1[/itex] is defined as
[tex]||f||_1 = \int |f(x)| dx[/tex]
where the integration is taken over [itex]\mathbb{R}[/itex] or whatever the underlying domain is. Then we say that a sequence of functions, say [itex]g_n[/itex], converges in norm to [itex]f[/itex] if
[tex]||f - g_n||_1 \rightarrow 0[/tex]
as [itex]n \rightarrow \infty[/itex]. There is a similar notion for [itex]L^2[/itex] and indeed any [itex]L^p[/itex] space.
If we take [itex]g_n[/itex] to be the n'th partial sum of the Fourier series of [itex]f[/itex], we thereby obtain another sense in which [itex]f[/itex] may "equal" its Fourier series. However, it's important to note that convergence in the norm can occur even in the absence of "almost everywhere" convergence, so in that sense it's a weaker form of convergence.
Last edited:
• #3
1,765
124
As far as physics goes, it is often said that Dirichlet solved the problem for most situations of physical interest:
http://en.wikipedia.org/wiki/Dirichlet_conditions
Developing stronger methods to deal with nastier functions that came up, for example, in number theory, played a big role in the development of modern mathematics (set theory, understanding the real numbers more deeply, Riemann sums, measure and integration, analytic number theory).
• #4
188
0
Thanks a lot! Particularly the Dirichlet conditions seem appropriate for me, but thanks for a great post anyway jbuniii.
So am I right in my understanding that the Dirichlet conditions give pointwise convergence , which in turn means that for any x the series converges to f(x)? And for discontinuities the value is the average of left and right limits.
I must confess I did not entirely follow the stuff on [itex]L^p[/itex] spaces. If equivalence classes are given by functions with equal measure, is the measure in [itex]\left( \int |f(x)-g(x)|^p dx\right)^{1/p}[/itex] the equivalence relation? And is convergence given by the fact that the difference in measure between a function and the partial sum goes to zero as N goes to infinity, i.e.,
[tex]\lim_{N\rightarrow \infty} ||f(x)-s_N||=\left( \int |f(x)-s_N|^p dx \right)^{1/p} =0 [/tex]
means convergence? So that would imply that it is the equivalence class of functions which converges and not the function itself, since the equivalent functions can't be distinguished?
I'm sorry if I'm rambling incoeherently and/or use incorrect terminology. Haven't really taken formal math courses in this subject.
• #5
jbunniii
Science Advisor
Homework Helper
Insights Author
Gold Member
3,394
180
I must confess I did not entirely follow the stuff on [itex]L^p[/itex] spaces.
Yes, I could see that you were mainly looking for a simple criterion for pointwise convergence, but you also asked about the other types of convergence and L^2 spaces, so I tried to give a sketch of how these work. You can see that there are a lot of technicalities involved.
If equivalence classes are given by functions with equal measure,
Slight correction: the equivalence classes are given by functions which are equal except on a set of measure zero. For example, let's consider what functions of a real variable are equivalent to the zero function, i.e. the function defined by f(x) = 0 for all real x.
In order to understand this, you have to know what is meant by a set of measure zero. This definition is actually quite simple: it is a set that can be covered by a collection of intervals of arbitrarily small total length. Any finite set has measure zero. Any countably infinite set has measure zero. This includes the set of integers and the set of rationals. The Cantor set is an uncountably infinite set with measure zero.
So, the following functions are equivalent to the zero function:
* g(x) = 1 if x is rational, 0 if x is irrational
* h(x) = 1 if x is in the Cantor set, 0 if it is not
is the measure in [itex]\left( \int |f(x)-g(x)|^p dx\right)^{1/p}[/itex] the equivalence relation?
The equivalence relation is: f ~ g if and only if [itex]m(\{x : f(x) \neq g(x)\}) = 0[/itex], where [itex]m[/itex] denotes the measure (generalized notion of length) of a set. This is equivalent to [itex]||f - g||_p = 0[/itex].
By the way, the reason for defining the [itex]L^p[/itex] spaces as spaces of equivalence classes instead of spaces of functions is so that the norm [itex]||f||_p[/itex] will satisfy [itex]||f||_p = 0[/itex] if and only if [itex]f = 0[/itex] (i.e. if and only if f is equivalent to zero). Otherwise we would have many elements of [itex]L^p[/itex] with zero "norm", which makes the space harder to work with.
And is convergence given by the fact that the difference in measure between a function and the partial sum goes to zero as N goes to infinity, i.e.,
[tex]\lim_{N\rightarrow \infty} ||f(x)-s_N||=\left( \int |f(x)-s_N|^p dx \right)^{1/p} =0 [/tex]
means convergence?
Yes this is convergence in the norm, which is a weaker notion that pointwise convergence, but still very useful in many contexts.
So that would imply that it is the equivalence class of functions which converges and not the function itself, since the equivalent functions can't be distinguished?
Yes, that's right. The integral in your expression above will have the exact same value if you replace [itex]f[/itex] by another member of its equivalence class, so there's no way to distinguish between them using this notion of convergence.
For a function in [itex]L^p[/itex] with [itex]p > 1[/itex], it is actually known that the Fourier series converges almost everywhere, which is a stronger notion than convergence in norm. It means that there is pointwise convergence at all points except possibly in a set of measure zero. This result is called the Carleson-Hunt theorem and was only proven in the 1960s; the proof is highly technical and understanding it requires a lot more knowledge than I have. This result is not true for [itex]L^1[/itex]; indeed, there is a counterexample of an [itex]f \in L^1[/itex] whose Fourier series diverges at all points.
I'm sorry if I'm rambling incoeherently and/or use incorrect terminology. Haven't really taken formal math courses in this subject.
I think you have understood the basic idea pretty well. Perhaps you'll find some of this intriguing enough to want to learn more. One or two courses in real analysis will probably get you there.
Last edited:
• #6
jbunniii
Science Advisor
Homework Helper
Insights Author
Gold Member
3,394
180
So am I right in my understanding that the Dirichlet conditions give pointwise convergence , which in turn means that for any x the series converges to f(x)? And for discontinuities the value is the average of left and right limits.
P.S. The answer to all of these question is yes. Note that the Dirichlet conditions are sufficient but not necessary.
• #7
188
0
Just wanted to throw in another thank you for your effort! Sure this is interesting stuff, perhaps some time I'll have time to take a real analysis course or at least look into it on my own a bit.
Related Threads on When is a function equal to its Fourier series?
• Last Post
Replies
2
Views
3K
Replies
9
Views
5K
Replies
7
Views
2K
• Last Post
Replies
10
Views
2K
• Last Post
Replies
3
Views
2K
• Last Post
Replies
4
Views
2K
Replies
8
Views
2K
• Last Post
Replies
1
Views
371
Replies
3
Views
1K
Top
|
__label__pos
| 0.825012 |
Environment for creative processing of text and numerical data
SURVO MM
Central limit theorem
S.Mustonen (2003)
Central limit theorem
Edit field:
1 *
2 *Central limit theorem
3 *
4 *Sucro SUMDISTR shows how the sum of independent random variables
5 *tends to the normal distribution when the number of variables grows.
6 *SUMDISTR works in the special case where the variables have the same
7 *discrete distribution given by the user.
8 *SUMDISTR displays density functions of sums on the screen automatically
9 *step by step and compares them to the normal distribution.
10 *It also computes a deviation from the normal distribution according to
11 *the Kolmogorov-Smirnov test statistics.
12 *
13 *Here only a collection of pictures is shown by letting the sucro
14 *save the partial graphs in a PostScript file.
15 *
16 *The sum distribution may have very interesting transient forms
17 *depending on the basic distribution before the ultimate 'normalization'.
18 *In this example we have a discrete uniform distribution with values
19 *0,1,2,...,19, but the probability of 19 is ten-fold when compared to
20 *others. Thus there is a peak on the right side of the distribution.
21 *
22 *It is sufficient to give values proportional to actual probabilities.
23 *MAT Q1=CON(20,1) / Definition of probabilities as a vector
24 *MAT Q1(20,1)=10 / Setting the peak
25 */SUMDISTR Q1 / NMAX=9 PS=SUM / Running the demo and saving the graphs
26 *
27 *Overlaying density function of normal distribution (SUM0, also plotted
28 *by SUMDISTR) and the densities of sums:
29 *EPS JOIN S1,SUM0,SUM1
30 *EPS JOIN S2,SUM0,SUM2
31 *EPS JOIN S3,SUM0,SUM3
32 *EPS JOIN S4,SUM0,SUM4
33 *EPS JOIN S5,SUM0,SUM5
34 *EPS JOIN S6,SUM0,SUM6
35 *EPS JOIN S7,SUM0,SUM7
36 *EPS JOIN S8,SUM0,SUM8
37 *EPS JOIN S9,SUM0,SUM9
38 *
39 *Combining the partial graphs and setting a 3 x 3 array of pictures
40 *as a PostScript file ALL.PS:
41 *EPS JOIN ALL,A1,A2,A3,A4,A5,A6,A7,A8,A9
42 *A1=S1,0000,1100,0.333,0.333
43 *A2=S2,0550,1100,0.333,0.333
44 *A3=S3,1100,1100,0.333,0.333
45 *A4=S4,0000,0550,0.333,0.333
46 *A5=S5,0550,0550,0.333,0.333
47 *A6=S6,1100,0550,0.333,0.333
48 *A7=S7,0000,0000,0.333,0.333
49 *A8=S8,0550,0000,0.333,0.333
50 *A9=S9,1100,0000,0.333,0.333
51 *A9=S9,1100,0000,0.333,0.333
52 *
Home | News | Publications | Download | Flash
Copyright © Survo Systems 2001-2008. All rights reserved.
Updated 2008-10-20 by webmaster'at'survo.fi.
Best viewed with any browser.
|
__label__pos
| 0.999606 |
Contact Us!
Please get in touch with us if you:
1. Have any suggestions
2. Have any questions
3. Have found an error/bug
4. Anything else ...
To contact us, please .
What is 25% off 280 Pounds
An item that costs £280, when discounted 25 percent, will cost £210
The easiest way of calculating discount is, in this case, to multiply the normal price £280 by 25 then divide it by one hundred. So, the discount is equal to £70. To calculate the sales price, simply deduct the discount of $70 from the original price £280 then get £210 as the sales price.
Percent-off Calculator?Please change values of the two first boxes of the calculator below to get answers to any combination of values. See details on how to calculate discounts, as well as, our discount calculator below to figure out discounts and the discounted prices of any item.
Inputs:
Original Price of the Item: £
Discount Percent (% off): %
Results:
Amount Saved (Discount): £
Sale / Discounted Price: £
See also: $£ Currency Converter
How to Calculate Discounts - Step-by-Step Solution
To calculate percent off use the following equations:
(1) Amount Saved = Original Price x Discount % / 100
(2) Sale Price = Original Price - Amount Saved
Here are the solutions to the questions stated above:
1) What is 25 percent (%) off £280?
Using the formula one and replacing the given values:
Amount Saved = Original Price x Discount % / 100. So,
Amount Saved = 280 x 25 / 100
Amount Saved = 7000 / 100
Amount Saved = $70 (answer)
In other words, a 25% discount for an item with original price of £280 is equal to £70 (Amount Saved).
Note that to find the amount saved, just multiply it by the percentage and divide by 100.
Supose Have you received a ROBLOX promotional code of 25 percent of discount. If the price is £280 what is the sales price:
2) How much to pay for an item of £280 when discounted 25 percent (%)? What is item's sale price?
Using the formula two and replacing the given values:
Sale Price = Original Price - Amount Saved. So,
Sale Price = 280 - 70
Sale Price = £210 (answer)
This means, the cost of the item to you is £210.
You will pay £210 for an item with original price of £280 when discounted 25%. In other words, if you buy an item at £280 with 25% discounts, you pay £280 - 70 = £210
Supose Have you received a amazon promo code of 70. If the price is £280 what was the amount saved in percent:
3) 70 is what percent off £280?
Using the formula two and replacing the given values:
Amount Saved = Original Price x Discount % /100. So,
70 = 280 x Discount % / 100
70 / 280 = Discount % /100
100 x 70 / 280 = Discount %
7000 / 280 = Discount %, or
Discount % = 25 (answer)
To find more examples, just choose one at the bottom of this page.
Discount Calculator
Discount or percent-off calculator
Please link to this page! Just right click on the above image, then choose copy link address, then past it in your HTML.
Sample Discount Calculations
Disclaimer
While every effort is made to ensure the accuracy of the information provided on this website, we offer no warranties in relation to these informations.
|
__label__pos
| 0.910204 |
Message-ID: <1007993662.1665.1416537314829.JavaMail.haus-conf@codehaus02.managed.contegix.com> Subject: Exported From Confluence MIME-Version: 1.0 Content-Type: multipart/related; boundary="----=_Part_1664_320642855.1416537314828" ------=_Part_1664_320642855.1416537314828 Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Content-Location: file:///C:/exported.html JOTM
JOTM
How To= Use JOTM as the XA Transaction Manager in Jetty
=20
These instructions have been tested with JOTM 2.0.10.
=20
Step 1: Copy the jars
=20
Assuming you have successfully downloaded JOTM, copy the followi= ng jars to jetty's lib/ext directory:
=20 =20
In your jetty installation, create the file resources/carol.proper= ties and edit its contents to contain these lines:
=20
=20
carol.start.ns=3Dfalse
carol.start.jndi=3Dfalse
carol.protocols=3Djrmp
carol.start.rmi=3Dfalse
carol.jvm.rmi.local.call=3Dtrue
carol.jndi.java.naming.factory.url.pkgs=3Dorg.mortbay.naming
=20
=20
Without this step, CAROL will assume control of JNDI from jetty and java:comp/env will not be set up correctly.
=20
Step 3: Configure the transaction manager and datasources
=20
You need to register an XA transaction manager and XA aware DataSources.= There is more information about jetty's JN= DI facilities that you may find useful. Here are the snippets for your = jetty config file, typically etc/jetty.xml. In this example, w= e will configure a Derby JDBC driver, but of course you can substi= tute your own.
=20
=20
<!----------------------------------------------------------------------=
---------------- -->
<!-- Configure a Jotm instance which provides a javax.transaction.Transa=
ctionManager -->
<!-- and a javax.transaction.UserTransaction implementation. =
-->
<!----------------------------------------------------------------------=
---------------- -->
<New id=3D"jotm" class=3D"org.objectweb.jotm.Jotm"&g=
t;
<Arg type=3D"boolean">True</Arg>
<Arg type=3D"boolean">False</Arg>
<Call id=3D"tm" name=3D"getTransactionManager"/>=
;
<Call id=3D"ut" name=3D"getUserTransaction"/>
</New>
<!----------------------------------------------------------------------=
---------------- -->
<!-- Set up the UserTransaction impl from JOTM as the transaction manage=
r for jetty -->
<!----------------------------------------------------------------------=
---------------- -->
<New class=3D"org.mortbay.jetty.plus.naming.Resource">
<Arg></Arg>
<Arg>javax.transaction.TransactionManager</Arg>
<Arg><Ref id=3D"ut"/></Arg>
</New>
<New id=3D"tx" class=3D"org.mortbay.jetty.plus.naming.T=
ransaction">
<Arg>
<Ref id=3D"ut"/>
</Arg>
</New>
=20
=20
At this point, you have JOTM acting as the transaction manager. Now, you= can define XA-aware DataSources. If you want them defined globally for all= webapps within your jetty installation, you can put them inside etc/= jetty.xml. Here's one example:
=20
=20
<!----------------------------------------------------------------------=
---------------- -->
<!-- Set up a DataSource that is XA aware. JOTM uses XAPool for this. =
-->
<!----------------------------------------------------------------------=
---------------- -->
<New class=3D"org.mortbay.jetty.plus.naming.Resource">
<Arg>myxadatasource</Arg>
<Arg>
<New id=3D"myxadatasourceA" class=3D"org.enhydra.jd=
bc.standard.StandardXADataSource">
<Set name=3D"DriverName">org.apache.derby.jdbc.Embe=
ddedDriver</Set>
<Set name=3D"Url">jdbc:derby:myderbyDB1A;create=3Dt=
rue</Set>
<Set name=3D"User"></Set>
<Set name=3D"Password"></Set>
<Set name=3D"transactionManager"><Ref id=3D"=
;tm"/></Set>
</New>
</Arg>
</New>
<New id=3D"mydatasource" class=3D"org.mortbay.jetty.plu=
s.naming.Resource">
<Arg>jdbc/mydatasource</Arg>
<Arg>
<New class=3D"org.enhydra.jdbc.pool.StandardXAPoolDataSource&q=
uot;>
<Arg><Ref id=3D"myxadatasourceA"/></Arg>
<Set name=3D"DataSourceName">myxadatasource</Set&=
gt;
</New>
</Arg>
</New>
<!-- If you want to be able to set up more references in webapp specific=
files -->
<!-- such as context deployment files and WEB-INF/jetty-env.xml files, y=
ou -->
<!-- need to save a reference to the JOTM tm object: =
-->
<Call name=3D"setAttribute">
<Arg>tm</Arg>
<Arg><Ref id=3D"tm"/></Arg>
</Call>
=20
=20
Now you can hookup a web.xml resource-ref entr= y for jdbc/mydatasource and then you'll be able to do lookups = in your webapp of java:comp/env/jdbc/mydatasource.
=20
=20
<!------------------------------------------------------------------->=
;
<!-- web.xml snippet ->=
;
<!------------------------------------------------------------------->=
;
<resource-ref>
<res-ref-name>jdbc/mydatasource</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
=20
=20
If instead you want to make DataSources that are restricted in scope to = only a particular webapp, then you need to put the declaration in a context= deployment file (ie a .xml file in $JETTY-HOME/contexts) or in a = WEB-INF/jetty-env.xml file, and you need to ensure that the or= g.mortbay.jetty.plus.naming.Resource declaration for the StandardXAPoolData= Source is scoped to the webapp by including as the first argument a referen= ce to the webapp. Here's an example from a xml context deployment file:
= =20
=20
<Configure id=3D'wac' class=3D"org.mortbay.jetty.webapp.WebAppConte=
xt">
<!------------------------------------------------------------------->=
;
<!-- Get the JOTM reference from the Server setup in etc/jetty.xml -->=
;
<!------------------------------------------------------------------->=
;
<Property name=3D"Server" id=3D"Server">
<Call id=3D"tm" name=3D"getAttribute">
<Arg>tm</Arg>
</Call>
</Property>
<!------------------------------------------------------------------->=
;
<!-- Set up the DataSource and XA-aware DataSources -->=
;
<!------------------------------------------------------------------->=
;
<New class=3D"org.mortbay.jetty.plus.naming.Resource">
<Arg>myxadatasource</Arg>
<Arg>
<New id=3D"myxadatasourceA" class=3D"org.enhydra.jd=
bc.standard.StandardXADataSource">
<Set name=3D"DriverName">org.apache.derby.jdbc.Embe=
ddedDriver</Set>
<Set name=3D"Url">jdbc:derby:myderbyDB1A;create=3Dt=
rue</Set>
<Set name=3D"User"></Set>
<Set name=3D"Password"></Set>
<Set name=3D"transactionManager"><Ref id=3D"=
;tm"/></Set>
</New>
</Arg>
</New>
<New id=3D"mydatasource" class=3D"org.mortbay.jetty.plu=
s.naming.Resource">
<Arg><Ref id=3D'wac'/></Arg>
<Arg>jdbc/mydatasource</Arg>
<Arg>
<New class=3D"org.enhydra.jdbc.pool.StandardXAPoolDataSource&q=
uot;>
<Arg><Ref id=3D"myxadatasourceA"/></Arg>
<Set name=3D"DataSourceName">myxadatasource</Set&=
gt;
</New>
</Arg>
</New>
<!------------------------------------------------------------------->=
;
<!-- If you want to also be able to define more JOTM DataSources -->=
;
<!-- from a WEB-INF/jetty-env.xml file, then you need to save the -->=
;
<!-- reference to the tm object into the webapp: -->=
;
<!------------------------------------------------------------------->=
;
<Call name=3D"setAttribute">
<Arg>tm</Arg>
<Arg><Ref id=3D"tm"/></Arg>
</Call>
=20
=20
NOTE in the example above, that the first org.mortbay.j= etty.plus.naming.Resource is actually declared to be in Server scope, by th= e absence of a webapp reference as the first argument. It is the second= org.mortbay.jetty.plus.naming.Resource (ie the one that you will look= up in your code) that uses the reference to the webapp. Ideally, both would= be webapp-specific, but JOTMs internal implementation of StandardXAPoolDat= aSource requires being able to lookup the StandardXADataSource by absolute = name, and thus it is easiest to declare that in the Server scope.
=20
For more information on scoping of JNDI entries, see the JNDI page. Also see the Atomikos page for information on an alternative XA manager that i= s a lot easier to configure.
=20
=20
Using XAPool
=20 Icon=20
=20
You MUST wrap the StandardXADataSource in a StandardX= APoolDataSource because StandardXADataSource does not u= se the XAConnection if you call getConnection(), thus connecti= ons won't be involved in the XA transaction.
=20
=20
------=_Part_1664_320642855.1416537314828--
|
__label__pos
| 0.979883 |
Beefy Boxes and Bandwidth Generously Provided by pair Networks
Perl-Sensitive Sunglasses
PerlMonks
alternation in regexes: to use or to avoid?
by dk (Chaplain)
on Dec 10, 2012 at 14:42 UTC ( #1008105=perlquestion: print w/replies, xml ) Need Help??
dk has asked for the wisdom of the Perl Monks concerning the following question:
Dear monks,
I've hit a performance issue with using | in regexes. It seems that in some (not-so-degenerated, actually) cases it loses significantly to looping over simple regexes i.e. $str =~ /$_// for @rx is much faster than $str =~ /$rx[0]|$rx[1]|$rx[2]/, which is rather counter-intuitive. Basically, for general cases, it would mean that alterations with grouping should be avoided at all, which is a strong statement and I wouldn't like it that way.
Is this a recognized problem? Is it a problem at all? Does it look like it needs to be reported as a bug? I can't decide myself.
Here's the test code:
use strict; use warnings; use Benchmark qw(:all); my $str = 'a' x 100; my @matchwords = qw( aol aachen aaliyah aaron abbas abbasid abbott abby abdul abe abel abel +ard abelson aberdeen abernathy abidjan abigail abilene abner abraham abram abrams +absalom abuja abyssinia abyssinian ac acadia acapulco accra acevedo achaean ); my $q1s = join('|', map { "$_\\s*\\w+" } @matchwords ); my $q1 = qr/$q1s/; my @q2s = map { "$_\\s*\\w+" } @matchwords; my @q2 = map { qr/$_/ } @q2s; my $q3s = join('|', map { "($_)\\s*\\w+" } @matchwords ); my $q3 = qr/$q3s/; my @q4s = map { "($_)\\s*\\w+" } @matchwords; my @q4 = map { qr/$_/ } @q4s; timethese( 100000, { 'alternation, no grouping' => sub { $str =~ /$q1/; }, 'loop, no grouping' => sub { for my $qr ( @q2 ) { $str =~ /$qr/; } }, 'alternation, grouping' => sub { $str =~ /$q3/; }, 'loop, grouping' => sub { for my $qr ( @q4 ) { $str =~ /$qr/; } }, });
Here's the output:
Benchmark: timing 100000 iterations ... alternation, grouping: 12 wallclock secs (11.92 usr + 0.00 sys = 11.9 +2 CPU) @ 8389.26/s (n=100000) alternation, no grouping: 0 wallclock secs ( 0.19 usr + 0.00 sys = +0.19 CPU) @ 526315.79/s (n=100000) (warning: too few iterations for a reliable count) loop, grouping: 2 wallclock secs ( 1.33 usr + 0.00 sys = 1.33 CPU) +@ 75187.97/s (n=100000) loop, no grouping: 1 wallclock secs ( 1.33 usr + 0.00 sys = 1.33 CP +U) @ 75187.97/s (n=100000)
Update: got same results on perls 5.10.1, 5.16.0, and 5.17.6
Replies are listed 'Best First'.
Re: alternation in regexes: to use or to avoid?
by Athanasius (Chancellor) on Dec 10, 2012 at 15:07 UTC
Perhaps the following quote from the Camel Book will shed some light on this question:
Short-circuit alternation is often faster than the corresponding regex. So:
print if /one-hump/ || /two/;
is likely to be faster than:
print if /one-hump|two/;
at least for certain values of one-hump and two. This is because the optimizer likes to hoist certain simple matching operations up into higher parts of the syntax tree and do very fast matching with a Boyer-Moore algorithm. A complicated pattern tends to defeat this.
— Tom Christiansen, brian d foy & Larry Wall with Jon Orwant, Programming Perl (4th Edition, 2012), p. 692.
Hope that helps,
Athanasius <°(((><contra mundum Iustus alius egestas vitae, eros Piratica,
Not really, because it says:
A complicated pattern tends to defeat this.
and i'm seeing exactly the opposite. I wish Tom would comment on that :) But thank you for the quote, it helps with understanding why I think that the observed behavior is bad.
Perhaps read "complicated" as "non-trivial", EG: having alternations
Re: alternation in regexes: to use or to avoid?
by ww (Bishop) on Dec 10, 2012 at 15:27 UTC
1. "Is this a recognized problem? Yes, see Athanasius', above.
2. "Is it a problem at all? Yes, but not one that's apt to be resolved other than by careful choice among the alternate approaches.
3. "Does it look like it needs to be reported as a bug? No; see 1 above
4. Does this "mean that alterations with grouping should be avoided at all...?" Definitely not; sometimes the difference in speed is too small to make any difference; sometimes the clarity of one approach clearly outweighs any other issues; and sometimes other factors, like personal taste, can be allowed to determine. Just be sure to think carefully about which applies.
Re: alternation in regexes: to use or to avoid?
by dave_the_m (Prior) on Dec 10, 2012 at 17:08 UTC
Your problem is that you are including the \s*\w+ and captures within the alternation. Move them outside and you'll find the alternations are suddenly much faster than the loops. This is because alternations containing just fixed strings can be much better optimised (using tries). With the following changes:
my $q1s = join('|', @matchwords); my $q1 = qr/$q1s\s*\w+/; my $q3s = join('|', @matchwords); my $q3 = qr/($q3s)\\s*\\w+/;
and setting the benchmark count 10x larger, I get on 5.17.6:
alternation, grouping: 1 wallclock secs ( 0.58 usr + 0.00 sys = 0.5 +8 CPU) @ 1724137.93/s (n=1000000) alternation, no grouping: 5 wallclock secs ( 4.85 usr + 0.00 sys = +4.85 CPU) @ 206185.57/s (n=1000000) loop, grouping: 24 wallclock secs (23.33 usr + 0.00 sys = 23.33 CPU) +@ 42863.27/s (n=1000000) loop, no grouping: 23 wallclock secs (22.57 usr + 0.00 sys = 22.57 CP +U) @ 44306.60/s (n=1000000)
Dave.
But that doesn't leave room for the various match-words to have different "\w+"'s - e.g. /\bFOO:\s*bar(\d+)/ or /\bBAZ:\s*(\w+)/
I guess I'm wondering why the trie-optimization isn't used for fixed string prefixes as well (as I'd assumed before I wrote the code).
Actually I stand corrected: the fixed string prefixes are collected together into a trie where there are (possibly differing) wildcard suffixes; the killer is the individual captures, which disables the trie optimisation.
So, alternation is the fastest, as long as you put any captures outside the alt.
Dave.
Re: alternation in regexes: to use or to avoid?
by RichardK (Parson) on Dec 10, 2012 at 15:31 UTC
It's not clear to me what you are trying to achieve with your regex.
The simple grouping that look like this
aol\s*\w+|aachen\s*\w+|aaliyah\s*\w+|.....
runs quickly, it's only the one with lots of capture groups that is slow. i.e
(aol)\s*\w+|(aachen)\s*\w+|(aaliyah)\s*\w+|....
So maybe there's just a better way to get the result you want, if you'd care to explain what that is?
(I work with dk.)
Another question could be: why is the one with the capture groups so slow, since none of the words match the string?
And in general, why is alternation&capture so much slower than looping&capture + alternation combined?
The reason for the code is to replace code with 60 or so similarly structured regexes in a library used by a couple of legacy applications with an automatically generated regex generated with info from configuration files, for both (potential) performance gains, allowing different behaviour across applications, and definite maintainability gains. The strings replaced all have the structure \bFOO:\s*bar(\d+) or \bBAZ:\s*(\w+) etc.
Suggestions like "Well, don't do that" are likely to go unheard :-)
OK then, If you want to use a non-optimal solution for operational reasons, go right ahead :-)
Added to balker's response, it's not that we're trying to achieve, we know other means how to get where we want to, but it's about the principle I've long nourished, (see Anastasius's quote above), and now it doesn't hold water. What i'd love to see, an explanation of someone who knows why regex algorithm exhibits behavior that is CONTRARY to perl lore.
Re: alternation in regexes: to use or to avoid?
by space_monk (Chaplain) on Dec 10, 2012 at 14:55 UTC
Trying to sound knowledgeable without knowing why or how you got the results you did, I would suspect that this is something that you can't rely on in every version of Perl, and possibly even system to system.
A Monk aims to give answers to those who have none, and to learn from those who know more.
Right, forgot that ... I tried it on 5.10, 5.16, and 5.17.6, with almost identical results. As to a system, I really doubt that it matters.
Re: alternation in regexes: to use or to avoid?
by Anonymous Monk on Dec 10, 2012 at 16:44 UTC
The amount of time the regex takes to execute is insignificant in the long run. What matters is how much I/O the program does or doesn't do, and that includes virtual-memory. Process the data in reasonably sized chunks, applying whatever you might know about which test is most likely to succeed first. Make the whole thing easy to maintain. Don't sweat nanoseconds when it's milliseconds that matter.
Thank you, but your statement is contradicting itself. We're seeing milliseconds wasted in the regex (for a web-app!), which is why we bothered to examine why in the first place.
Log In?
Username:
Password:
What's my password?
Create A New User
Node Status?
node history
Node Type: perlquestion [id://1008105]
Approved by moritz
help
Chatterbox?
and all is quiet...
How do I use this? | Other CB clients
Other Users?
Others examining the Monastery: (4)
As of 2016-12-11 12:22 GMT
Sections?
Information?
Find Nodes?
Leftovers?
Voting Booth?
On a regular basis, I'm most likely to spy upon:
Results (169 votes). Check out past polls.
|
__label__pos
| 0.74837 |
GenerateGeodatabaseParameters extension property
3589
3
03-26-2015 04:39 AM
CeyhunYilmaz
New Contributor III
Can I obtain more information about GenerateGeodatabaseParameters object's extension property? Can we say that we can editing only in within geometry area ?
0 Kudos
3 Replies
LucasDanzinger
Esri Frequent Contributor
By extension property, do you mean extent property? When you generate a geodatabase from the server, and specify the extent in the parameters, that does 2 things- first, it only retrieves the features within that extent and puts those into the local gdb. Second, it restricts editing to that extent, so even if your user were add a feature outside of the extent, or try to update a feature's geometry to be outside of the geodatabase extent, it would not be successfully added back to the server once the sync happens. Take a look at the Local geodatabase editing sample in the QML Sample App. If you zoom into some specific area and generate, notice that if you zoom out, the features outside the extent are not visible. Select a feature and attempt to move it outside of the extent, and it will not work.
Hope this helps.
Luke
0 Kudos
KK2014
by
New Contributor III
Hİ Lucas,
Are there any advantages for user ?
Thanks
0 Kudos
LucasDanzinger
Esri Frequent Contributor
Hi KK,
I'm not sure that I follow- advantages for the user compared to what? When you edit features, you will either be working with the GeodatabaseFeatureTable (which is offline and takes in a geodatabase) or the GeodatabaseFeatureServiceTable (which is online and takes in a service url). When you generate an offline geodatabase from server, you will switch from GeodatabaseFeatuerServiceTable to GeodatabaseFeatureTable. The API for both scenarios should be nearly identical.
Thanks,
Luke
0 Kudos
|
__label__pos
| 0.909471 |
0 follower
CMap
Package system.collections
Inheritance class CMap » CComponent
Implements IteratorAggregate, ArrayAccess, Countable, Traversable
Subclasses CAttributeCollection, CConfiguration, CCookieCollection, CFormElementCollection, CTypedMap
Since 1.0
Source Code framework/collections/CMap.php
CMap implements a collection that takes key-value pairs.
You can access, add or remove an item with a key by using itemAt, add, and remove. To get the number of the items in the map, use getCount. CMap can also be used like a regular array as follows,
$map[$key]=$value; // add a key-value pair
unset($map[$key]); // remove the value with the specified key
if(isset($map[$key])) // if the map contains the key
foreach($map as $key=>$value) // traverse the items in the map
$n=count($map); // returns the number of items in the map
Public Properties
Hide inherited properties
PropertyTypeDescriptionDefined By
count integer Returns the number of items in the map. CMap
iterator CMapIterator Returns an iterator for traversing the items in the list. CMap
keys array the key list CMap
readOnly boolean whether this map is read-only or not. CMap
Public Methods
Hide inherited methods
MethodDescriptionDefined By
__call() Calls the named method which is not a class method. CComponent
__construct() Constructor. CMap
__get() Returns a property value, an event handler list or a behavior based on its name. CComponent
__isset() Checks if a property value is null. CComponent
__set() Sets value of a component property. CComponent
__unset() Sets a component property to be null. CComponent
add() Adds an item into the map. CMap
asa() Returns the named behavior object. CComponent
attachBehavior() Attaches a behavior to this component. CComponent
attachBehaviors() Attaches a list of behaviors to the component. CComponent
attachEventHandler() Attaches an event handler to an event. CComponent
canGetProperty() Determines whether a property can be read. CComponent
canSetProperty() Determines whether a property can be set. CComponent
clear() Removes all items in the map. CMap
contains() CMap
copyFrom() Copies iterable data into the map. CMap
count() Returns the number of items in the map. CMap
detachBehavior() Detaches a behavior from the component. CComponent
detachBehaviors() Detaches all behaviors from the component. CComponent
detachEventHandler() Detaches an existing event handler. CComponent
disableBehavior() Disables an attached behavior. CComponent
disableBehaviors() Disables all behaviors attached to this component. CComponent
enableBehavior() Enables an attached behavior. CComponent
enableBehaviors() Enables all behaviors attached to this component. CComponent
evaluateExpression() Evaluates a PHP expression or callback under the context of this component. CComponent
getCount() Returns the number of items in the map. CMap
getEventHandlers() Returns the list of attached event handlers for an event. CComponent
getIterator() Returns an iterator for traversing the items in the list. CMap
getKeys() Returns the key list CMap
getReadOnly() Returns whether this map is read-only or not. Defaults to false. CMap
hasEvent() Determines whether an event is defined. CComponent
hasEventHandler() Checks whether the named event has attached handlers. CComponent
hasProperty() Determines whether a property is defined. CComponent
itemAt() Returns the item with the specified key. CMap
mergeArray() Merges two or more arrays into one recursively. CMap
mergeWith() Merges iterable data into the map. CMap
offsetExists() Returns whether there is an element at the specified offset. CMap
offsetGet() Returns the element at the specified offset. CMap
offsetSet() Sets the element at the specified offset. CMap
offsetUnset() Unsets the element at the specified offset. CMap
raiseEvent() Raises an event. CComponent
remove() Removes an item from the map by its key. CMap
toArray() CMap
Protected Methods
Hide inherited methods
MethodDescriptionDefined By
setReadOnly() Sets whether this list is read-only or not CMap
Property Details
count property read-only
public integer getCount()
Returns the number of items in the map.
iterator property read-only
Returns an iterator for traversing the items in the list. This method is required by the interface IteratorAggregate.
keys property read-only
public array getKeys()
the key list
readOnly property
public boolean getReadOnly()
protected void setReadOnly(boolean $value)
whether this map is read-only or not. Defaults to false.
Method Details
__construct() method
public void __construct(array $data=NULL, boolean $readOnly=false)
$data array the initial data. Default is null, meaning no initialization.
$readOnly boolean whether the list is read-only
Source Code: framework/collections/CMap.php#53 (show)
public function __construct($data=null,$readOnly=false)
{
if(
$data!==null)
$this->copyFrom($data);
$this->setReadOnly($readOnly);
}
Constructor. Initializes the list with an array or an iterable object.
add() method
public void add(mixed $key, mixed $value)
$key mixed key
$value mixed value
Source Code: framework/collections/CMap.php#136 (show)
public function add($key,$value)
{
if(!
$this->_r)
{
if(
$key===null)
$this->_d[]=$value;
else
$this->_d[$key]=$value;
}
else
throw new
CException(Yii::t('yii','The map is read only.'));
}
Adds an item into the map. Note, if the specified key already exists, the old value will be overwritten.
clear() method
public void clear()
Source Code: framework/collections/CMap.php#179 (show)
public function clear()
{
foreach(
array_keys($this->_d) as $key)
$this->remove($key);
}
Removes all items in the map.
contains() method
public boolean contains(mixed $key)
$key mixed the key
{return} boolean whether the map contains an item with the specified key
Source Code: framework/collections/CMap.php#189 (show)
public function contains($key)
{
return isset(
$this->_d[$key]) || array_key_exists($key,$this->_d);
}
copyFrom() method
public void copyFrom(mixed $data)
$data mixed the data to be copied from, must be an array or object implementing Traversable
Source Code: framework/collections/CMap.php#208 (show)
public function copyFrom($data)
{
if(
is_array($data) || $data instanceof Traversable)
{
if(
$this->getCount()>0)
$this->clear();
if(
$data instanceof CMap)
$data=$data->_d;
foreach(
$data as $key=>$value)
$this->add($key,$value);
}
elseif(
$data!==null)
throw new
CException(Yii::t('yii','Map data must be an array or an object implementing Traversable.'));
}
Copies iterable data into the map. Note, existing data in the map will be cleared first.
count() method
public integer count()
{return} integer number of items in the map.
Source Code: framework/collections/CMap.php#93 (show)
public function count()
{
return
$this->getCount();
}
Returns the number of items in the map. This method is required by Countable interface.
getCount() method
public integer getCount()
{return} integer the number of items in the map
Source Code: framework/collections/CMap.php#102 (show)
public function getCount()
{
return
count($this->_d);
}
Returns the number of items in the map.
getIterator() method
public CMapIterator getIterator()
{return} CMapIterator an iterator for traversing the items in the list.
Source Code: framework/collections/CMap.php#82 (show)
public function getIterator()
{
return new
CMapIterator($this->_d);
}
Returns an iterator for traversing the items in the list. This method is required by the interface IteratorAggregate.
getKeys() method
public array getKeys()
{return} array the key list
Source Code: framework/collections/CMap.php#110 (show)
public function getKeys()
{
return
array_keys($this->_d);
}
getReadOnly() method
public boolean getReadOnly()
{return} boolean whether this map is read-only or not. Defaults to false.
Source Code: framework/collections/CMap.php#63 (show)
public function getReadOnly()
{
return
$this->_r;
}
itemAt() method
public mixed itemAt(mixed $key)
$key mixed the key
{return} mixed the element at the offset, null if no element is found at the offset
Source Code: framework/collections/CMap.php#121 (show)
public function itemAt($key)
{
if(isset(
$this->_d[$key]))
return
$this->_d[$key];
else
return
null;
}
Returns the item with the specified key. This method is exactly the same as offsetGet.
mergeArray() method
public static array mergeArray(array $a, array $b)
$a array array to be merged to
$b array array to be merged from. You can specify additional arrays via third argument, fourth argument etc.
{return} array the merged array (the original arrays are not changed.)
Source Code: framework/collections/CMap.php#282 (show)
public static function mergeArray($a,$b)
{
$args=func_get_args();
$res=array_shift($args);
while(!empty(
$args))
{
$next=array_shift($args);
foreach(
$next as $k => $v)
{
if(
is_integer($k))
isset(
$res[$k]) ? $res[]=$v $res[$k]=$v;
elseif(
is_array($v) && isset($res[$k]) && is_array($res[$k]))
$res[$k]=self::mergeArray($res[$k],$v);
else
$res[$k]=$v;
}
}
return
$res;
}
Merges two or more arrays into one recursively. If each array has an element with the same string key value, the latter will overwrite the former (different from array_merge_recursive). Recursive merging will be conducted if both arrays have an element of array type and are having the same key. For integer-keyed elements, the elements from the latter array will be appended to the former array.
See Also
mergeWith() method
public void mergeWith(mixed $data, boolean $recursive=true)
$data mixed the data to be merged with, must be an array or object implementing Traversable
$recursive boolean whether the merging should be recursive.
Source Code: framework/collections/CMap.php#240 (show)
public function mergeWith($data,$recursive=true)
{
if(
is_array($data) || $data instanceof Traversable)
{
if(
$data instanceof CMap)
$data=$data->_d;
if(
$recursive)
{
if(
$data instanceof Traversable)
{
$d=array();
foreach(
$data as $key=>$value)
$d[$key]=$value;
$this->_d=self::mergeArray($this->_d,$d);
}
else
$this->_d=self::mergeArray($this->_d,$data);
}
else
{
foreach(
$data as $key=>$value)
$this->add($key,$value);
}
}
elseif(
$data!==null)
throw new
CException(Yii::t('yii','Map data must be an array or an object implementing Traversable.'));
}
Merges iterable data into the map.
Existing elements in the map will be overwritten if their keys are the same as those in the source. If the merge is recursive, the following algorithm is performed:
• the map data is saved as $a, and the source data is saved as $b;
• if $a and $b both have an array indexed at the same string key, the arrays will be merged using this algorithm;
• any integer-indexed elements in $b will be appended to $a and reindexed accordingly;
• any string-indexed elements in $b will overwrite elements in $a with the same index;
offsetExists() method
public boolean offsetExists(mixed $offset)
$offset mixed the offset to check on
{return} boolean
Source Code: framework/collections/CMap.php#309 (show)
public function offsetExists($offset)
{
return
$this->contains($offset);
}
Returns whether there is an element at the specified offset. This method is required by the interface ArrayAccess.
offsetGet() method
public mixed offsetGet(integer $offset)
$offset integer the offset to retrieve element.
{return} mixed the element at the offset, null if no element is found at the offset
Source Code: framework/collections/CMap.php#321 (show)
public function offsetGet($offset)
{
return
$this->itemAt($offset);
}
Returns the element at the specified offset. This method is required by the interface ArrayAccess.
offsetSet() method
public void offsetSet(integer $offset, mixed $item)
$offset integer the offset to set element
$item mixed the element value
Source Code: framework/collections/CMap.php#333 (show)
public function offsetSet($offset,$item)
{
$this->add($offset,$item);
}
Sets the element at the specified offset. This method is required by the interface ArrayAccess.
offsetUnset() method
public void offsetUnset(mixed $offset)
$offset mixed the offset to unset element
Source Code: framework/collections/CMap.php#344 (show)
public function offsetUnset($offset)
{
$this->remove($offset);
}
Unsets the element at the specified offset. This method is required by the interface ArrayAccess.
remove() method
public mixed remove(mixed $key)
$key mixed the key of the item to be removed
{return} mixed the removed value, null if no such key exists.
Source Code: framework/collections/CMap.php#155 (show)
public function remove($key)
{
if(!
$this->_r)
{
if(isset(
$this->_d[$key]))
{
$value=$this->_d[$key];
unset(
$this->_d[$key]);
return
$value;
}
else
{
// it is possible the value is null, which is not detected by isset
unset($this->_d[$key]);
return
null;
}
}
else
throw new
CException(Yii::t('yii','The map is read only.'));
}
Removes an item from the map by its key.
setReadOnly() method
protected void setReadOnly(boolean $value)
$value boolean whether this list is read-only or not
Source Code: framework/collections/CMap.php#71 (show)
protected function setReadOnly($value)
{
$this->_r=$value;
}
toArray() method
public array toArray()
{return} array the list of items in array
Source Code: framework/collections/CMap.php#197 (show)
public function toArray()
{
return
$this->_d;
}
|
__label__pos
| 0.733136 |
Adam Alter’s Irresistible: Why We Can’t Stop Checking, Scrolling, Clicking and Watching
I have a lot of sympathy for Adam Alter’s case in Irresistible: Why We Can’t Stop Checking, Scrolling, Clicking and Watching. Despite the abundant benefits of being online, the hours I have burnt over the last 20 years through aimless internet wandering and social media engagement could easily have delivered a book or another PhD.
It’s unsurprising that we are surrounded by addictive tech. Game, website and app designers are all designing their products to gain and hold our attention. In particular, the tools at the disposal of modern developers are fantastic at introducing what Alter describes as the six ingredients of behavioural addition:
[C]ompelling goals that are just beyond reach; irresistible and unpredictable positive feedback; a sense of incremental progress and improvement; tasks that become slowly more difficult over time; unresolved tensions that demand resolution; and strong social connections.
Behavioural addictions have a lot of similarity with substance addictions (some people question whether we should distinguish between them at all). They activate the same brain regions. They are fueled by some of the same human needs, such as the need for social engagement and support, mental stimulation and a sense of effectiveness. [Parts of the book seem to be a good primer on addiction, although see my endnote.]
Based on one survey of the literature, as many as 41 per cent of the population may have suffered a behavioural addiction in the past month. While having so many people classified as addicts dilutes the concept of “addiction”, it does not seem unrealistic given the way many people use tech.
As might be expected given the challenge, Alter’s solutions on how we can manage addiction in the modern world fall somewhat short of providing a fix. For one, Alter suggests we need to start training the young when they are first exposed to technology. However, it is likely that the traps present in later life will be much different from those present when young. After all, most of Alter’s examples of addicts were born well before the advent of World of Warcraft, the iPhone or the iPad that derailed them.
Further, the ability of tech to capture our attention is only in its infancy. It is not hard to imagine the eventual creation of immersive virtual worlds so attractive that some people will never want to leave.
Alter’s chapter on gamification is interesting. Gamification is the idea of turning a non-game experience into a game. One of the more inane but common examples of gamification is turning a set of stairs into a piano to encourage people to take those stairs in preference to the neighbouring escalator (see on YouTube). People get more exercise as a result.
The flip side is that gamification is part of the problem itself (unsurprising given the theme of Alter’s book). For example, exercise addicts using wearables can lose sight of why they are exercising. They push on for their gamified goals despite injuries and other costs. One critic introduced by Alter is particularly scathing:
Bogost suggested that gamification “was invented by consultants as a means to capture the wild, coveted beast that is video games and to domesticate it.” Bogost criticized gamification because it undermined the “gamer’s” well-being. At best, it was indifferent to his well-being, pushing an agenda that he had little choice but to pursue. Such is the power of game design: a well-designed game fuels behavioral addiction. …
But Bogost makes an important point when he says that not everything should be a game. Take the case of a young child who prefers not to eat. One option is to turn eating into a game—to fly the food into his mouth like an airplane. That makes sense right now, maybe, but in the long run the child sees eating as a game. It takes on the properties of games: it must be fun and engaging and interesting, or else it isn’t worth doing. Instead of developing the motivation to eat because food is sustaining and nourishing, he learns that eating is a game.
Taking this critique further, Alter notes that “[c]ute gamified interventions like the piano stairs are charming, but they’re unlikely to change how people approach exercise tomorrow, next week, or next year.” [Also read this story about Bogost and his game Cow Clicker.]
There are plenty of other interesting snippets in the book. Here’s one on uncertainty of reward:
Each one [pigeon] waddled up to a small button and pecked persistently, hoping that it would release a tray of Purina pigeon pellets. … During some trials, Zeiler would program the button so it delivered food every time the pigeons pecked; during others, he programmed the button so it delivered food only some of the time. Sometimes the pigeons would peck in vain, the button would turn red, and they’d receive nothing but frustration.
When I first learned about Zeiler’s work, I expected the consistent schedule to work best. If the button doesn’t predict the arrival of food perfectly, the pigeon’s motivation to peck should decline, just as a factory worker’s motivation would decline if you only paid him for some of the gadgets he assembled. But that’s not what happened at all. Like tiny feathered gamblers, the pigeons pecked at the button more feverishly when it released food 50–70 percent of the time. (When Zeiler set the button to produce food only once in every ten pecks, the disheartened pigeons stopped responding altogether.) The results weren’t even close: they pecked almost twice as often when the reward wasn’t guaranteed. Their brains, it turned out, were releasing far more dopamine when the reward was unexpected than when it was predictable.
I have often wondered to what extent surfing is attractive due to the uncertain arrival of waves during a session, or the inconsistency in swell from day-to-day.
———
Now for a closing gripe. Alter tells the following story:
When young adults begin driving, they’re asked to decide whether to become organ donors. Psychologists Eric Johnson and Dan Goldstein noticed that organ donations rates in Europe varied dramatically from country to country. Even countries with overlapping cultures differed. In Denmark the donation rate was 4 percent; in Sweden it was 86 percent. In Germany the rate was 12 percent; in Austria it was nearly 100 percent. In the Netherlands, 28 percent were donors, while in Belgium the rate was 98 percent. Not even a huge educational campaign in the Netherlands managed to raise the donation rate. So if culture and education weren’t responsible, why were some countries more willing to donate than others?
The answer had everything to do with a simple tweak in wording. Some countries asked drivers to opt in by checking a box:
If you are willing to donate your organs, please check this box: □
Checking a box doesn’t seem like a major hurdle, but even small hurdles loom large when people are trying to decide how their organs should be used when they die. That’s not the sort of question we know how to answer without help, so many of us take the path of least resistance by not checking the box, and moving on with our lives. That’s exactly how countries like Denmark, Germany, and the Netherlands asked the question—and they all had very low donation rates.
Countries like Sweden, Austria, and Belgium have for many years asked young drivers to opt out of donating their organs by checking a box:
If you are NOT willing to donate your organs, please check this box: □
The only difference here is that people are donors by default. They have to actively check a box to remove themselves from the donor list. It’s still a big decision, and people still routinely prefer not to check the box. But this explains why some countries enjoy donation rates of 99 percent, while others lag far behind with donation rates of just 4 percent.
This story is rubbish, as I have posted about here, here, here and here. This difference has nothing to do with ticking boxes on driver’s licence forms. In Austria they are never even asked. 99 per cent of Austrians aren’t organ donors in the way anyone would normally define it. 99% are presumed to consent, and if they happen to die their organs might not be taken because the family objects (or whatever other obstacle gets in the way) in the absence of any understanding of the actual intentions of the deceased.
To top it off, Alter embellishes the incorrect version of the story as told by Daniel Kahneman or Dan Ariely with phrasing from driver’s licence forms that simply don’t exist. Did he even read the Johnson and Goldstein paper (ungated copy)?
After reading a well-written and entertaining book about a subject I don’t know much about, I’m left questioning whether this is a single slip or Alter’s general approach to his writing and research. How many other factoids from the book simply won’t hold up once I go to the original source?
Author: Jason Collins
Economics. Behavioural and data science. PhD economics and evolutionary biology. Blog at jasoncollins.blog
3 thoughts on “Adam Alter’s Irresistible: Why We Can’t Stop Checking, Scrolling, Clicking and Watching”
1. Without having read the book, I’d say the author’s approach to gamification a little lacking. It can and is used within marketing as a point of engagement, in some ways like a foot in the door. It doesn’t necessarily mean it will change a person’s entire range of responses and behaviours around whatever ‘mundane’ task or habit has been slightly enlivened. From an anecdotal point of view, I suspect that millions of people have used the plane/train feeding approach for children and I’m not sure this gamification has necessarily proven maladaptive. If you want to know where the game is, it’s in the social and networking media spaces where you need to keep pressing the buttons in order to ‘stay alive’, kind of like a tamagotchi.
2. Your last paragraph is an instance of what Michael Crichton called the Gell-Mann Amnesia effect:
“Briefly stated, the Gell-Mann Amnesia effect is as follows. You open the newspaper to an article on some subject you know well. In Murray’s case, physics. In mine, show business. You read the article and see the journalist has absolutely no understanding of either the facts or the issues. Often, the article is so wrong it actually presents the story backward—reversing cause and effect. I call these the “wet streets cause rain” stories. Paper’s full of them.
In any case, you read with exasperation or amusement the multiple errors in a story, and then turn the page to national or international affairs, and read as if the rest of the newspaper was somehow more accurate about Palestine than the baloney you just read. You turn the page, and forget what you know.”
The speech that quote comes from is well worth reading.
Comments welcome
Fill in your details below or click an icon to log in:
WordPress.com Logo
You are commenting using your WordPress.com account. Log Out / Change )
Google photo
You are commenting using your Google account. Log Out / Change )
Twitter picture
You are commenting using your Twitter account. Log Out / Change )
Facebook photo
You are commenting using your Facebook account. Log Out / Change )
Connecting to %s
|
__label__pos
| 0.596106 |
The Complete Computing Environment
Clight
LifeTechEmacsTopicsArcology
Clight is software which tints a Linux computer display to remove blue light from the light spectrum and adjusts the brightness based on webcam or light sensor state. Various qualities of science is out on whether this helps you sleep, but it's valuable to me to match the light temperature of my display match that of my lights, and I find that warmer lights cause less strain. Additionally, Clight lets me scale down the backlight volume and the gamma ramps. I run it simply as a SystemD User Service.
{ ... }:
{
services.clight.enable = true;
services.clight.settings = {
inhibit.inhibit_docked = true;
backlight.ac_timeouts = [ 120 300 60 ];
backlight.batt_timeouts = [ 120 300 60 ];
backlight.pause_on_lid_closed = true;
backlight.capture_on_lid_opened = true;
sensor.ac_regression_points = [ 0.20 0.29 0.45 0.61 0.74 0.81 0.88 0.93 0.97 1.0 ];
sensor.batt_regression_points = [ 0.20 0.23 0.36 0.52 0.59 0.65 0.71 0.75 0.78 0.80 ];
keyboard.dim = true;
};
location.provider = "geoclue2";
}
|
__label__pos
| 0.927236 |
La guía definitiva sobre cómo sumar celdas de un mismo color en Excel
¡Bienvenidos al blog JMJ Informático! En el artículo de hoy vamos a aprender cómo sumar celdas de un mismo color en Excel. Aprenderemos el truco para agilizar nuestros cálculos y optimizar nuestro trabajo. Así que ¡prepárate para sacar el máximo partido a esta maravillosa herramienta!
ÍNDICE
1. Cómo sumar celdas de un mismo color en Excel: una guía para optimizar tus cálculos informáticos.
2. ¿Cuál es la forma de contar celdas del mismo color en Excel?
3. ¿Cómo realizar la suma de las celdas resaltadas en Excel?
4. ¿Cómo se utiliza la función sumar sí?
5. ¿Cómo realizar la suma de celdas que contienen un texto en Excel?
6. Preguntas Frecuentes
1. ¿Cómo puedo sumar celdas de un mismo color en Excel?
2. ¿Existe alguna fórmula o función específica para sumar celdas de un mismo color en Excel?
3. ¿Es posible crear una macro o script que sume automáticamente las celdas de un mismo color en Excel?
Cómo sumar celdas de un mismo color en Excel: una guía para optimizar tus cálculos informáticos.
Cómo sumar celdas de un mismo color en Excel: una guía para optimizar tus cálculos informáticos.
La suma de celdas en Excel es una tarea común al trabajar con hojas de cálculo. Sin embargo, a veces es necesario realizar cálculos más complejos, como sumar solo las celdas de un mismo color. Afortunadamente, Excel ofrece una función llamada "SUMAR.SI.CONJUNTO" que nos permite hacer esto de manera sencilla.
Paso 1: Abre tu hoja de cálculo de Excel y selecciona el rango de celdas del cual deseas sumar solo las que tienen un mismo color. Puedes hacer esto manteniendo presionada la tecla "Ctrl" mientras haces clic en cada celda.
Paso 2: En la barra de fórmulas, escribe "=SUMAR.SI.CONJUNTO(" seguido de un paréntesis abierto.
Paso 3: Ahora, debemos definir los criterios para la suma. En este caso, queremos sumar las celdas que tengan un mismo color. Para hacer esto, necesitamos utilizar la función "COLOR.DE.FONDO" dentro de la fórmula "SUMAR.SI.CONJUNTO".
Paso 4: Escribe nuevamente el rango de celdas seleccionadas en el Paso 1 después de la función "COLOR.DE.FONDO". Esto indicará a Excel que solo debe sumar las celdas que tengan el mismo color que las seleccionadas.
Paso 5: Cierra el paréntesis de la función "SUMAR.SI.CONJUNTO" y presiona la tecla "Enter". Excel calculará automáticamente la suma de las celdas del mismo color.
Paso 6: Si deseas actualizar la suma cuando cambies el color de las celdas, simplemente selecciona nuevamente el rango de celdas y presiona "Enter".
Recuerda que la función "SUMAR.SI.CONJUNTO" también se puede utilizar para sumar celdas que cumplan con otros criterios, como valores mayores a un determinado número o texto específico en una columna.
Optimiza tus cálculos informáticos en Excel al utilizar la función "SUMAR.SI.CONJUNTO" para sumar celdas de un mismo color. Esto te ahorrará tiempo y te permitirá realizar análisis más precisos en tu hoja de cálculo.
¿Cuál es la forma de contar celdas del mismo color en Excel?
En Excel, puedes contar celdas del mismo color utilizando una fórmula que combina las funciones "CONTAR.SI" y "COLOR.DE.CELDA".
RecomendadoCómo calcular el TIN y el TAE en Excel: una guía paso a pasoCómo calcular el TIN y el TAE en Excel: una guía paso a paso
Paso 1: Define el rango de celdas en el que deseas contar los colores. Por ejemplo, si quieres contar las celdas de color rojo en el rango A1:A10, selecciona ese rango.
Paso 2: Abre la barra de fórmulas y escribe la siguiente fórmula:
=CONTAR.SI(A1:A10;COLOR.DE.CELDA(A1))
Esta fórmula cuenta las celdas del rango seleccionado que tienen el mismo color que la celda A1, que es la primera celda del rango.
Paso 3: Presiona Enter para obtener el resultado. La fórmula contará y mostrará el número de celdas del mismo color que A1 en el rango seleccionado.
Recuerda que, al utilizar esta fórmula, debes asegurarte de que la función "COLOR.DE.CELDA" devuelva correctamente el color de la celda a contar. Además, ten en cuenta que esta fórmula solo cuenta celdas del mismo color que la celda de referencia (A1 en este ejemplo).
Importante: En versiones más recientes de Excel, es posible que la función "COLOR.DE.CELDA" no esté disponible. En su lugar, puedes utilizar la función "IGUAL" para comparar el color RGB de las celdas. Por ejemplo:
=CONTAR.SI(A1:A10;IGUAL(COLOR(RGB(255;0;0));COLOR(RGB(A1))))
Esta fórmula cuenta las celdas del rango A1:A10 que tienen el mismo color RGB que la celda A1, la cual es de color rojo (RGB(255;0;0)). Recuerda ajustar los valores RGB según el color que desees contar.
¿Cómo realizar la suma de las celdas resaltadas en Excel?
Para realizar la suma de las celdas resaltadas en Excel, podemos utilizar la función SUMA.
1. Selecciona la celda donde deseas que aparezca el resultado de la suma.
2. Escribe la siguiente fórmula: =SUMA(rango de celdas).
3. Dentro de los paréntesis, especifica el rango de celdas que deseas sumar. Puedes hacer esto de dos formas:
a) Si las celdas están contiguas, puedes escribir directamente la referencia del primer y último rango separados por ":". Por ejemplo, "=SUMA(A1:A5)" realizará la suma de las celdas A1, A2, A3, A4 y A5.
b) Si las celdas no están contiguas, selecciona cada una manteniendo presionada la tecla "Ctrl" y luego escribe la función. Por ejemplo, "=SUMA(A1,A3,A5)" realizará la suma de las celdas A1, A3 y A5.
4. Pulsa Enter para obtener el resultado.
En resumen, utiliza la función SUMA seguida del rango de celdas que deseas sumar, ya sea contiguo o no, dentro de los paréntesis.
RecomendadoCómo rellenar con ceros a la izquierda en Excel: Guía completa y ejemplosCómo rellenar con ceros a la izquierda en Excel: Guía completa y ejemplos
¿Cómo se utiliza la función sumar sí?
La función "sumar sí" es una función que se utiliza en hojas de cálculo, como Microsoft Excel o Google Sheets, para realizar sumas condicionales. Esta función permite sumar un rango de celdas solo si cumple ciertos criterios especificados.
La sintaxis básica de la función "sumar sí" es la siguiente:
=SUMAR.SI(rango, criterio, [rango_suma])
Donde:
• "rango" es el rango de celdas que se evaluarán.
• "criterio" es la condición que se debe cumplir para incluir una celda en la suma.
• "[rango_suma]" (opcional) es el rango de celdas que se sumarán si cumplen el criterio. Si no se especifica, se sumarán las celdas del rango inicial.
Por ejemplo, supongamos que tenemos una columna A con nombres de productos y una columna B con sus respectivos precios. Queremos sumar únicamente los precios de los productos que sean frutas.
En este caso, podemos usar la función "sumar sí" de la siguiente manera:
=SUMAR.SI(A:A, "fruta", B:B)
Esto sumará los valores de la columna B únicamente si el valor correspondiente en la columna A es "fruta".
Es importante destacar que la función "sumar sí" puede ser utilizada con otros operadores como "", "=", "" para realizar comparaciones numéricas.
Recuerda utilizar las etiquetas para destacar las partes importantes de tu respuesta.
¿Cómo realizar la suma de celdas que contienen un texto en Excel?
Para realizar la suma de celdas que contienen un texto en Excel, se puede utilizar la función SUMAR.SI. Esta función permite sumar los valores de un rango de celdas siempre y cuando cumplan con una condición específica.
A continuación te explico cómo utilizar esta función:
RecomendadoCómo crear gráficos en 3D en Excel y darle vida a tus datosCómo crear gráficos en 3D en Excel y darle vida a tus datos
1. Selecciona la celda donde quieres que aparezca el resultado de la suma.
2. Escribe la fórmula "=SUMAR.SI(rango, criterio)" en la celda seleccionada. Donde "rango" es el rango de celdas que deseas sumar y "criterio" es el texto que debe cumplir la condición.
3. Por ejemplo, si deseas sumar las celdas del rango A1:A5 que contengan el texto "ejemplo", la fórmula sería: "=SUMAR.SI(A1:A5, "ejemplo")".
4. Pulsa Enter y obtendrás el resultado de la suma.
Es importante tener en cuenta que la función SUMAR.SI solo suma las celdas que cumplen con la condición establecida, ignorando aquellas que no la cumplen. Además, si las celdas contienen números, la función los considerará como cero para la suma.
Espero que esta información te sea útil. Recuerda utilizar el formato adecuado de la función SUMAR.SI y adaptarla a tus necesidades específicas.
Preguntas Frecuentes
¿Cómo puedo sumar celdas de un mismo color en Excel?
Para sumar celdas de un mismo color en Excel, puedes utilizar la función SUMAR.SI. Esta función te permite sumar los valores de un rango de celdas que cumplan con un determinado criterio. En este caso, debes especificar el color como criterio utilizando el formato RGB. Por ejemplo, si quieres sumar las celdas verdes, el argumento del criterio sería "=RGB(0,255,0)".
¿Existe alguna fórmula o función específica para sumar celdas de un mismo color en Excel?
¿Es posible crear una macro o script que sume automáticamente las celdas de un mismo color en Excel?
Sí, es posible crear una macro o script en Excel que sume automáticamente las celdas de un mismo color.
Una clave final para sumar celdas de un mismo color en Excel es utilizar la función SUMAR.SI.CONJUNTO. Esta función nos permite sumar valores en función de uno o más criterios, incluyendo el color de las celdas.
Para utilizar esta función, sigue estos pasos:
1. Selecciona la celda donde deseas mostrar el resultado de la suma.
2. Escribe la fórmula: =SUMAR.SI.CONJUNTO(rango, criterio_rango, criterio_color).
3. En "rango", selecciona el rango de celdas donde se encuentran los valores que deseas sumar.
4. En "criterio_rango", selecciona el rango de celdas que contiene los colores que quieres filtrar.
5. En "criterio_color", selecciona una única celda del rango de "criterio_rango" que corresponda al color que deseas filtrar.
Por ejemplo, si quieres sumar todas las celdas de color rojo en un rango A1:A10, y tienes los colores en el rango B1:B10, la fórmula sería:
=SUMAR.SI.CONJUNTO(A1:A10, B1:B10, B1).
RecomendadoCómo contar valores repetidos en Excel: trucos y fórmulas imprescindiblesCómo contar valores repetidos en Excel: trucos y fórmulas imprescindibles
Esta función te ayudará a sumar fácilmente los valores de celdas con un mismo color en Excel.
Deja una respuesta
Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *
Go up
Usamos cookies para mejorar la experiencia en nuestra web. Si continuas navegando, asumiremos que estás de acuerdo con ello. Más información
|
__label__pos
| 0.961581 |
Date:2011-03-16 03:38:46 (9 years 3 months ago)
Author:Maarten ter Huurne
Commit:ff3fd14930dfdcd55fab93547972eded674b94a5
Message:MIPS: A320: Add Dingoo A320 board support.
This is a squashed version of the development done in the jz-2.6.38 branch.
Files: arch/mips/jz4740/Kconfig (1 diff)
arch/mips/jz4740/Makefile (1 diff)
arch/mips/jz4740/board-a320.c (1 diff)
Change Details
arch/mips/jz4740/Kconfig
1818 bool "Sungale id800wt picture frame"
1919 select SOC_JZ4740
2020
21config JZ4740_A320
22 bool "Dingoo A320 game and media player"
23 select SYS_SUPPORTS_ZBOOT
24
2125endchoice
2226
2327config HAVE_PWM
arch/mips/jz4740/Makefile
1515obj-$(CONFIG_JZ4740_N516) += board-n516.o board-n516-display.o
1616obj-$(CONFIG_JZ4740_N526) += board-n526.o
1717obj-$(CONFIG_JZ4740_ID800WT) += board-id800wt.o
18obj-$(CONFIG_JZ4740_A320) += board-a320.o
1819
1920# PM support
2021
arch/mips/jz4740/board-a320.c
1/*
2 * linux/arch/mips/jz4740/board-a320.c
3 *
4 * JZ4740 A320 board setup routines.
5 *
6 * Copyright (c) 2006-2007 Ingenic Semiconductor Inc.
7 * Copyright (c) 2009 Ignacio Garcia Perez <[email protected]>
8 * Copyright (c) 2010-2011 Maarten ter Huurne <[email protected]>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
15#include <linux/init.h>
16#include <linux/sched.h>
17#include <linux/ioport.h>
18#include <linux/mm.h>
19#include <linux/console.h>
20#include <linux/delay.h>
21#include <linux/kernel.h>
22#include <linux/gpio.h>
23#include <linux/i2c.h>
24#include <linux/i2c-gpio.h>
25#include <linux/power_supply.h>
26#include <linux/power/gpio-charger.h>
27#include <linux/power/jz4740-battery.h>
28
29#include <linux/pwm_backlight.h>
30#include <linux/input.h>
31#include <linux/gpio_keys.h>
32
33#include <asm/cpu.h>
34#include <asm/bootinfo.h>
35#include <asm/mipsregs.h>
36#include <asm/reboot.h>
37
38#include <asm/mach-jz4740/gpio.h>
39#include <asm/mach-jz4740/jz4740_fb.h>
40#include <asm/mach-jz4740/jz4740_mmc.h>
41#include <asm/mach-jz4740/jz4740_nand.h>
42#include <asm/mach-jz4740/platform.h>
43
44#include "clock.h"
45
46/*
47 * This is called by the panic reboot delay loop if panic=<n> parameter
48 * is passed to the kernel. The A320 does not have any LEDs, so the best
49 * we can do is to blink the LCD backlight.
50 *
51 * TODO(MtH): This should use the backlight driver instead of directly
52 * manipulating the GPIO pin.
53 */
54static long a320_panic_blink_callback(int time)
55{
56 gpio_direction_output(JZ_GPIO_PORTD(31), (time / 500) & 1);
57 return 0;
58}
59
60#ifdef CONFIG_I2C_GPIO
61/* I2C over GPIO pins */
62static struct i2c_gpio_platform_data a320_i2c_pdata = {
63 .sda_pin = JZ_GPIO_PORTD(23),
64 .scl_pin = JZ_GPIO_PORTD(24),
65 .udelay = 2,
66 .timeout = 3 * HZ,
67};
68
69static struct platform_device a320_i2c_device = {
70 .name = "i2c-gpio",
71 .id = -1,
72 .dev = {
73 .platform_data = &a320_i2c_pdata,
74 },
75};
76#endif
77
78/* NAND */
79#define A320_NAND_PAGE_SIZE (4096ull)
80#define A320_NAND_ERASE_BLOCK_SIZE (128 * A320_NAND_PAGE_SIZE)
81
82static struct mtd_partition a320_nand_partitions[] = {
83 { .name = "SPL",
84 .offset = 0 * A320_NAND_ERASE_BLOCK_SIZE,
85 .size = 1 * A320_NAND_ERASE_BLOCK_SIZE,
86 /* MtH: Read-only until we can trust it. */
87 .mask_flags = MTD_WRITEABLE,
88 },
89 { .name = "uC/OS-II loader",
90 .offset = 1 * A320_NAND_ERASE_BLOCK_SIZE,
91 .size = 2 * A320_NAND_ERASE_BLOCK_SIZE,
92 /* MtH: Read-only until we can trust it. */
93 .mask_flags = MTD_WRITEABLE,
94 },
95 /* erase block 3 is empty (maybe alternative location for bbt?) */
96 /* erase block 4 contains the bad block table */
97 { .name = "uC/OS-II Z:",
98 .offset = 5 * A320_NAND_ERASE_BLOCK_SIZE,
99 .size = 127 * A320_NAND_ERASE_BLOCK_SIZE,
100 /* MtH: Read-only until we can trust it. */
101 .mask_flags = MTD_WRITEABLE,
102 },
103 { .name = "uC/OS-II A:",
104 .offset = 132 * A320_NAND_ERASE_BLOCK_SIZE,
105 .size = (8192 - 132) * A320_NAND_ERASE_BLOCK_SIZE,
106 /* MtH: Read-only until we can trust it. */
107 .mask_flags = MTD_WRITEABLE,
108 },
109};
110
111static uint8_t a320_nand_bbt_pattern[] = {'b', 'b', 't', '8' };
112
113static struct nand_bbt_descr a320_nand_bbt_main_descr = {
114 .options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT,
115 /* TODO(MtH): Maybe useful flags for the future:
116 NAND_BBT_CREATE | NAND_BBT_WRITE | NAND_BBT_VERSION | NAND_BBT_PERCHIP
117 */
118 .pages = { 4 * A320_NAND_ERASE_BLOCK_SIZE / A320_NAND_PAGE_SIZE },
119 .maxblocks = 1,
120 .pattern = a320_nand_bbt_pattern,
121 .len = ARRAY_SIZE(a320_nand_bbt_pattern),
122 .offs = 128 - ARRAY_SIZE(a320_nand_bbt_pattern),
123};
124
125static struct nand_ecclayout a320_nand_ecc_layout = {
126 .eccbytes = 72,
127 .eccpos = {
128 4, 5, 6, 7, 8, 9, 10, 11, 12, /* sector 0 */
129 16, 17, 18, 19, 20, 21, 22, 23, 24, /* sector 1 */
130 28, 29, 30, 31, 32, 33, 34, 35, 36, /* sector 2 */
131 40, 41, 42, 43, 44, 45, 46, 47, 48, /* sector 3 */
132 52, 53, 54, 55, 56, 57, 58, 59, 60, /* sector 4 */
133 64, 65, 66, 67, 68, 69, 70, 71, 72, /* sector 5 */
134 76, 77, 78, 79, 80, 81, 82, 83, 84, /* sector 6 */
135 88, 89, 90, 91, 92, 93, 94, 95, 96, /* sector 7 */
136 },
137 .oobfree = {
138 { .offset = 100, .length = 22 },
139 }
140};
141
142static void a320_nand_ident(struct platform_device *pdev,
143 struct nand_chip *chip,
144 struct mtd_partition **partitions,
145 int *num_partitions)
146{
147 chip->options |= NAND_USE_FLASH_BBT;
148 chip->bbt_td = &a320_nand_bbt_main_descr;
149 /* MtH: I did not find a mirror bbt yet, but it might exist. */
150 chip->bbt_md = NULL;
151}
152
153static struct jz_nand_platform_data a320_nand_pdata = {
154 .num_partitions = ARRAY_SIZE(a320_nand_partitions),
155 .partitions = a320_nand_partitions,
156 .ecc_layout = &a320_nand_ecc_layout,
157 .busy_gpio = JZ_GPIO_PORTC(30),
158 .banks = { 1, 2, 3, 4 },
159 .ident_callback = a320_nand_ident,
160};
161
162/* Display */
163static struct fb_videomode a320_video_modes[] = {
164 {
165 .name = "320x240",
166 .xres = 320,
167 .yres = 240,
168 // TODO(MtH): Set refresh or pixclock.
169 .vmode = FB_VMODE_NONINTERLACED,
170 },
171};
172
173static struct jz4740_fb_platform_data a320_fb_pdata = {
174 .width = 60,
175 .height = 45,
176 .num_modes = ARRAY_SIZE(a320_video_modes),
177 .modes = a320_video_modes,
178 .bpp = 16,
179 .lcd_type = JZ_LCD_TYPE_SMART_PARALLEL_16_BIT,
180 .pixclk_falling_edge = 0,
181 .chip_select_active_low = 1,
182 .register_select_active_low = 1,
183};
184
185static int a320_backlight_notify(struct device *dev, int brightness)
186{
187 if (!gpio_get_value(JZ_GPIO_PORTB(18))) {
188 /* RESET_N pin of the ILI chip is pulled down,
189 so force backlight off. */
190 return 0;
191 }
192
193 return brightness;
194}
195
196static struct platform_pwm_backlight_data a320_backlight_pdata = {
197 .pwm_id = 7,
198 .max_brightness = 255,
199 .dft_brightness = 100,
200 .pwm_period_ns = 5000000,
201 .notify = a320_backlight_notify,
202};
203
204static struct platform_device a320_backlight_device = {
205 .name = "pwm-backlight",
206 .id = -1,
207 .dev = {
208 .platform_data = &a320_backlight_pdata,
209 },
210};
211
212static struct jz4740_mmc_platform_data a320_mmc_pdata = {
213 .gpio_card_detect = JZ_GPIO_PORTB(29),
214 .gpio_read_only = -1,
215 .gpio_power = -1,
216 // TODO(MtH): I don't know which GPIO pin the SD power is connected to.
217 // Booboo left power alone, but I don't know why.
218 //.gpio_power = GPIO_SD_VCC_EN_N,
219 //.power_active_low = 1,
220};
221
222/* Battery */
223static struct jz_battery_platform_data a320_battery_pdata = {
224 // TODO(MtH): Sometimes while charging, the GPIO pin quickly flips between
225 // 0 and 1. This causes a very high CPU load because the kernel
226 // will invoke a hotplug event handler process on every status
227 // change. Until it is clear how to avoid or handle that, it
228 // is better not to use the charge status.
229 //.gpio_charge = JZ_GPIO_PORTB(30),
230 .gpio_charge = -1,
231 .gpio_charge_active_low = 1,
232 .info = {
233 .name = "battery",
234 .technology = POWER_SUPPLY_TECHNOLOGY_LIPO,
235 .voltage_max_design = 4200000,
236 .voltage_min_design = 3600000,
237 },
238};
239
240static char *a320_batteries[] = {
241 "battery",
242};
243
244static struct gpio_charger_platform_data a320_charger_pdata = {
245 .name = "usb",
246 .type = POWER_SUPPLY_TYPE_USB,
247 .gpio = JZ_GPIO_PORTD(28),
248 .gpio_active_low = 0,
249 .supplied_to = a320_batteries,
250 .num_supplicants = ARRAY_SIZE(a320_batteries),
251};
252
253static struct platform_device a320_charger_device = {
254 .name = "gpio-charger",
255 .dev = {
256 .platform_data = &a320_charger_pdata,
257 },
258};
259
260 /* TODO(CongoZombie): Figure out a way to reimplement power slider functionality
261 so that existing apps won't break. (Possible that an SDL
262 remapping would fix this, but it is unclear how many apps
263 use other interfaces)
264 Original Dingux used SysRq keys to perform different tasks
265 (restart, backlight, volume etc.)
266 */
267 /* TODO(CongoZombie): Confirm power slider pin (Booboo's docs seem unsure) */
268
269static struct gpio_keys_button a320_buttons[] = {
270 /* D-pad up */ {
271 .gpio = JZ_GPIO_PORTD(6),
272 .active_low = 1,
273 .code = KEY_UP
274 },
275 /* D-pad down */ {
276 .gpio = JZ_GPIO_PORTD(27),
277 .active_low = 1,
278 .code = KEY_DOWN
279 },
280 /* D-pad left */ {
281 .gpio = JZ_GPIO_PORTD(5),
282 .active_low = 1,
283 .code = KEY_LEFT
284 },
285 /* D-pad right */ {
286 .gpio = JZ_GPIO_PORTD(18),
287 .active_low = 1,
288 .code = KEY_RIGHT
289 },
290 /* A button */ {
291 .gpio = JZ_GPIO_PORTD(0),
292 .active_low = 1,
293 .code = KEY_LEFTCTRL
294 },
295 /* B button */ {
296 .gpio = JZ_GPIO_PORTD(1),
297 .active_low = 1,
298 .code = KEY_LEFTALT
299 },
300 /* X button */ {
301 .gpio = JZ_GPIO_PORTD(19),
302 .active_low = 1,
303 .code = KEY_SPACE
304 },
305 /* Y button */ {
306 .gpio = JZ_GPIO_PORTD(2),
307 .active_low = 1,
308 .code = KEY_LEFTSHIFT
309 },
310 /* Left shoulder button */ {
311 .gpio = JZ_GPIO_PORTD(14),
312 .active_low = 1,
313 .code = KEY_TAB
314 },
315 /* Right shoulder button */ {
316 .gpio = JZ_GPIO_PORTD(15),
317 .active_low = 1,
318 .code = KEY_BACKSPACE
319 },
320 /* START button */ {
321 .gpio = JZ_GPIO_PORTC(17),
322 .active_low = 1,
323 .code = KEY_ENTER
324 },
325 /* SELECT button */ {
326 .gpio = JZ_GPIO_PORTD(17),
327 .active_low = 1,
328 .code = KEY_ESC
329 },
330 /* POWER slider */ {
331 .gpio = JZ_GPIO_PORTD(29),
332 .active_low = 1,
333 .code = KEY_POWER,
334 .wakeup = 1,
335 },
336 /* POWER hold */ {
337 .gpio = JZ_GPIO_PORTD(22),
338 .active_low = 1,
339 .code = KEY_PAUSE
340 },
341};
342
343static struct gpio_keys_platform_data a320_gpio_keys_pdata = {
344 .buttons = a320_buttons,
345 .nbuttons = ARRAY_SIZE(a320_buttons),
346 .rep = 1,
347};
348
349static struct platform_device a320_gpio_keys_device = {
350 .name = "gpio-keys",
351 .id = -1,
352 .dev = {
353 .platform_data = &a320_gpio_keys_pdata,
354 },
355};
356
357static struct platform_device *jz_platform_devices[] __initdata = {
358#ifdef CONFIG_I2C_JZ47XX
359 &jz4740_i2c_device,
360#endif
361#ifdef CONFIG_I2C_GPIO
362 &a320_i2c_device,
363#endif
364 /* USB host is not usable since the PCB does not route the pins to
365 * a place where new wires can be soldered. */
366 /*&jz4740_usb_ohci_device,*/
367 &jz4740_udc_device,
368 &jz4740_mmc_device,
369 &jz4740_nand_device,
370 &jz4740_framebuffer_device,
371 &jz4740_pcm_device,
372 &jz4740_i2s_device,
373 &jz4740_codec_device,
374 &jz4740_rtc_device,
375 &jz4740_adc_device,
376 &jz4740_wdt_device,
377 &a320_charger_device,
378 &a320_backlight_device,
379 &a320_gpio_keys_device,
380};
381
382static void __init board_gpio_setup(void)
383{
384 /* We only need to enable/disable pullup here for pins used in generic
385 * drivers. Everything else is done by the drivers themselves. */
386
387 /* Disable pullup of the USB detection pin: on the A320 pullup or not
388 * seems to make no difference, but on A330 the signal will be unstable
389 * when the pullup is enabled. */
390 jz_gpio_disable_pullup(JZ_GPIO_PORTD(28));
391}
392
393static int __init a320_init_platform_devices(void)
394{
395 jz4740_framebuffer_device.dev.platform_data = &a320_fb_pdata;
396 jz4740_nand_device.dev.platform_data = &a320_nand_pdata;
397 jz4740_adc_device.dev.platform_data = &a320_battery_pdata;
398 jz4740_mmc_device.dev.platform_data = &a320_mmc_pdata;
399
400 jz4740_serial_device_register();
401
402 return platform_add_devices(jz_platform_devices,
403 ARRAY_SIZE(jz_platform_devices));
404}
405
406struct jz4740_clock_board_data jz4740_clock_bdata = {
407 .ext_rate = 12000000,
408 .rtc_rate = 32768,
409};
410
411static int __init a320_board_setup(void)
412{
413 printk(KERN_INFO "JZ4740 A320 board setup\n");
414
415 panic_blink = a320_panic_blink_callback;
416
417 board_gpio_setup();
418
419 if (a320_init_platform_devices())
420 panic("Failed to initalize platform devices\n");
421
422 return 0;
423}
424
425arch_initcall(a320_board_setup);
Archive Download the corresponding diff file
interactive
|
__label__pos
| 0.999408 |
[view addSubview:myView] - problem
Discussion in 'iPhone/iPad Programming' started by Danneman101, Feb 25, 2009.
1. macrumors 6502
Joined:
Aug 14, 2008
#1
Im getting a very weird behaviour from when I add a subview to my main view in one function (the viewWillAppear), and then remove it in another function (webViewDidFinishLoading).
I need the delay between them in order to measure how long the ActivityIndicator should be active (which is until the webpage loaded into the UIWebView is completely loaded, which the webViewDidFinishLoad-function indicates).
Most things function as normal. What does not function, and actually halts the entire app, are links (clicked on <a href="">-tags) from within the various html-pages loaded into the UIWebView.
This is the code-snippet:
Code:
// 1. Before the UIWebView is loaded, we load an UIActivityIndicator into the main view
- (void)viewWillAppear:(BOOL)animated
{
activityView = [[UIActivityIndicatorView alloc] initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge];
activityView.frame = CGRectMake(143.0f, 250.0f, 32.0f, 32.0f);
[self.view addSubview:activityView];
[activityView startAnimating];
[activityView release];
}
// 2. Then removes the UIActivityIndicator when the UIWebView has been loades
- (void)webViewDidFinishLoad:(UIWebView *)webView
{
[activityView stopAnimating];
[activityView removeFromSuperview];
}
Note that this seems to have nothing to do with the UIActivityIndicator as such, since Ive also tried loading a UIView in the first function, and removing it in the second, and end up with the same problem.
Also, if I remove the activityView in the first function (which would remove it too soon), this problem disappears.
The same is true if I remove it for instance in a viewDidFinishLoad()-function instead. This will however also remove it too soon, making this solution a no go for my purpose.
Ive also tried adding the subview to, for instance the webview instead, but the same problem presists even then.
Any idea as to how to solve this problem?
2. Guest
caveman_uk
Joined:
Feb 17, 2003
Location:
Hitchin, Herts, UK
#2
The reason is failing is that viewWillAppear is called only once when a view appears (obviously) but webViewDidFinishLoad is called every time the webView finishes loading anything. So when you click on a link the method is called when the new page gets loaded. Note that there will not have been a matching call to viewWillAppear in that case. So you would be trying to remove a subview that isn't actually in the view hierarchy.
Can't you just hide the subview rather than remove it?
3. thread starter macrumors 6502
Joined:
Aug 14, 2008
#3
Oh, so that is why the app hangs when a link is clicked - because the uiwebview is reloaded, the webViewDidFinishLoad is called again, and this time it tries to remove the activityView that isn't there anymore. Ok, I think I get it :)
Ive found a good function to use to hide the UIActivityIndicatorView in the webViewDidFinishLoad:
Code:
[activityView stopAnimating];
[activityView hidesWhenStopped];
Question 1:
My concern is, wont this create a lot of duplicate instances of the activityView, since the old ones are just hidden, not really removed? Or are they automatically replaced by the new version of the instance once the:
Code:
activityView = [[UIActivityIndicatorView alloc] initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge];
..is executed?
Question 2:
Would a better solution be to place a remove-code inside another function that is called only ONCE when the uiwebview already has been first loaded (not on reload, as does the webViewDidFinishLoad)? Is there even such a function?
Question 3:
The ideal solution, though, would be to create an empty, white UIView that the activity indictator is loaded into, so that the background is always the same. However, I cant find a similar hide-function for a UIView?
4. thread starter macrumors 6502
Joined:
Aug 14, 2008
#4
I found that this method seems to be appropriate to "hide" a UIView:
Code:
[self.view sendSubviewToBack:progressAlert];
Works fine.
The only thing Im concerned about is the memory-management. Should I dealloc the UIView and the UIActivityIndicatorView in the dealloc-method, perhaps? Or is the release-method enough to prevent building up the memory?
Share This Page
|
__label__pos
| 0.957485 |
Thread Closed
Complementary Logic
Share Thread
Nov6-03, 08:39 AM #1
Complementary Logic
Dear peolpe,
I am a poor formalist, but have some ideas, which are based on structural|quantitative point of view on Math language.
They can be found here: http://www.geocities.com/complementa...y/CATpage.html
Maybe you can help me to address these ideas in a rigorous formal way.
By doing it, we can check what idea can survive rigorous definitions.
I think that only then we can move to the next step, which is: to examine its originality.
Thank you,
Yours,
Organic
----------------------------------------------------------------------------
Short overview:
Boolean logic is based on 0 Xor 1.
Fuzzy logic is fading transition between 0 Xor 1.
A non-Boolean logic is based on 0 And 1.
My point of view leading me to what I call Complementary logic, which is a fading transition between Boolean logic (0 Xor 1) and non-boolean logic (0 And 1), for example:
Number 4 is fading transition between multiplication 1*4 and addition ((((+1)+1)+1)+1) ,and vice versa.
This fading transition can be represented as:
Code:
(1*4)= (1,1,1,1) <------------- Maximum symmetry-degree,
((1*2)+1*2)= ((1,1),1,1) Minimum information's clarity-degree (no uniqueness)
(((+1)+1)+1*2)= (((1),1),1,1)
((1*2)+(1*2))= ((1,1),(1,1))
(((+1)+1)+(1*2))= (((1),1),(1,1))
(((+1)+1)+((+1)+1))=(((1),1),((1),1))
((1*3)+1)= ((1,1,1),1)
(((1*2)+1)+1)= (((1,1),1),1)
((((+1)+1)+1)+1)= ((((1),1),1),1) <------ Minimum symmetry-degree,
Maximum information's clarity-degree (uniqueness)
Multiplication can be operated only among objects with structural identity .
Also multiplication is noncommutative, for example:
2*3 = ( (1,1),(1,1),(1,1) ) or ( ((1),1),((1),1),((1),1) )
3*2 = ( (1,1,1),(1,1,1) ) or ( ((1,1),1),((1,1),1) ) or ( (((1),1),1),(((1),1),1) )
Through my point of view, there are connections between structure's symmetry-degree and information's clarity-degree.
High Entropy means maximum level of redundancy and uncertainty, which are based on the highest symmetry-degree of some system.
For example let us say that there is a piano with 3 notes and we call it 3-system :
DO=D , RE=R , MI=M
The highest Entropy level of 3-system is the most left information's-tree,
where each key has no unique value of its own, and vice versa.
Code:
<-Redundancy->
M M M ^<----Uncertainty
R R R | R R
D D D | D D M D R M
. . . v . . . . . .
| | | | | | | | |
3 = | | | |___|_ | |___| |
| | | | | | |
|___|___|_ |_______| |_______|
| | |
An example of 4-notes piano:
DO=D , RE=R , MI=M , FA=F
Code:
------------>>>
F F F F F F F F
M M M M M M M M
R R R R R R R R R R R R R R
D D D D D D D D D R D D D D D D
. . . . . . . . . . . . . . . .
| | | | | | | | | | | | | | | |
| | | | |__|_ | | |__| | | |__|_ |__|_
| | | | | | | | | | | |
| | | | | | | | | | | |
| | | | | | | | | | | |
|__|__|__|_ |_____|__|_ |_____|__|_ |_____|____
| | | |
4 =
M M M
R R R R R R R
D R D D D R D R D D D F D D M F
. . . . . . . . . . . . . . . .
| | | | | | | | | | | | | | | |
|__| |__|_ |__| |__| | | | | |__|_ | |
| | | | | | | | | | |
| | | | |__|__|_ | |_____| |
| | | | | | | |
|_____|____ |_____|____ |________| |________|
| | | |
D R M F
. . . .
| | | |
|__| | |
| | |
|_____| |
| |
|________|
|
PhysOrg.com mathematics news on PhysOrg.com
>> Pendulum swings back on 350-year-old mathematical mystery
>> Bayesian statistics theorem holds its own - but use with caution
>> Math technique de-clutters cancer-cell data, revealing tumor evolution, treatment leads
Thread Closed
Similar discussions for: Complementary Logic
Thread Forum Replies
Help with complementary CE BJT amp Electrical Engineering 0
O.D.E. Complementary and Particular Solution Calculus & Beyond Homework 1
Complementary Slackeness Calculus & Beyond Homework 0
What is Complementary Logic General Physics 211
What is Complementary Logic? General Physics 8
|
__label__pos
| 0.920365 |
4
$\begingroup$
I want to evaluate a sum like $\sum\limits_{j > i}^n q_i^k\, q_j^k$, where $n$ is the length of the vector $q^k$. The vector $q^k$ is, for example, $[q_1, q_2, q_3, q_4]$ and $i$ and $j$ correspond to the index of the vector elements.
This was my attempt; I got errors :/
enter image description here
$\endgroup$
2
• $\begingroup$ Are the vectors large? Is the desired sum over subsets other than size 2 also? Are the vectors numeric? If so, there are considerably faster methods than those already posted. $\endgroup$
– ciao
Sep 24 '16 at 23:29
• $\begingroup$ I am using small test cases for now, but the length of each additional vector I try to analyze increases exponentially, so it can get large. The Hamiltonian I am working with ought to be 2-local and the vectors are binary. $\endgroup$ Sep 25 '16 at 0:00
11
$\begingroup$
vec = Table[q[i], {i, 4}]
(* {q[1], q[2], q[3], q[4]} *)
With[{l = Length[vec]},
Sum[vec[[i]] vec[[j]], {i, 1, l}, {j, i + 1, l}]
]
(* q[1] q[2] + q[1] q[3] + q[2] q[3] + q[1] q[4] + q[2] q[4] + q[3] q[4] *)
Plus @@ Times @@@ Subsets[vec, {2}]
(* q[1] q[2] + q[1] q[3] + q[2] q[3] + q[1] q[4] + q[2] q[4] + q[3] q[4] *)
Update
For binary vectors (see OP's comment), a fast approach would be:
vec = RandomInteger[{0, 1}, 10^6];
Binomial[Total[vec], 2] // RepeatedTiming
(* {0.0010, 124964252556} *)
(* comparison of the result with Jim Baldwin's answer *)
%[[2]] === (Total[vec^k]^2 - Total[vec^(2 k)])/2
(* True *)
$\endgroup$
11
$\begingroup$
SymmetricPolynomial is the built-in way to get the sums you want:
vec = Table[q[i], {i, 4}];
SymmetricPolynomial[2, vec^k]
(* q[1]^k q[2]^k+q[1]^k q[3]^k+q[2]^k q[3]^k+q[1]^k q[4]^k+q[2]^k q[4]^k+q[3]^k q[4]^k *)
(But @Xavier 's way will help you understand Mathematica better.)
Update
To follow up on @ciao 's comment, if the values are numeric, then there are definitely better ways. For your example, the following works:
n = 4000;
k = 2;
vec = Abs[RandomVariate[NormalDistribution[1, 0.2], n]];
Timing[(Total[vec^k]^2 - Total[vec^(2 k)])/2]
(* {0.`,8.583920493183017`*^6} *)
Timing[SymmetricPolynomial[2, vec^k]]
(* {2.6364169`,8.583920493183037`*^6} *)
Note the difference in timing. The point is that one can determine such sums as you have using just using the sums of the powers of the vector elements.
$\endgroup$
Your Answer
By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy
Not the answer you're looking for? Browse other questions tagged or ask your own question.
|
__label__pos
| 0.894002 |
Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files
SCM Repository
[smlnj] View of /sml/branches/FLINT/src/compiler/PervEnv/Basis/int-inf.sml
ViewVC logotype
View of /sml/branches/FLINT/src/compiler/PervEnv/Basis/int-inf.sml
Parent Directory Parent Directory | Revision Log Revision Log
Revision 227 - (download) (annotate)
Sat Apr 17 17:15:03 1999 UTC (20 years, 5 months ago) by monnier
File size: 29065 byte(s)
version 110.12
(* int-inf.sml
*
* COPYRIGHT (c) 1995 by AT&T Bell Laboratories. See COPYRIGHT file for details.
*
* This package is derived from Andrzej Filinski's bignum package.
*
* It is implemented almost totally on the abstraction presented by
* the BigNat structure. The only concrete type information it assumes
* is that BigNat.bignat = 'a list and that BigNat.zero = [].
* Some trivial additional efficiency could be obtained by assuming that
* type bignat is really int list, and that if (v : bignat) = [d], then
* bignat d = [d].
*
* At some point, this should be reimplemented to make use of Word32, or
* have compiler/runtime support.
*
* Also, for booting, this module could be broken into one that has
* all the types and arithmetic functions, but doesn't use NumScan,
* constructing values from strings using bignum arithmetic. Various
* integer and word scanning, such as NumScan, could then be constructed
* from LargeInt. Finally, a user-level LargeInt could be built by
* importing the basic LargeInt, but replacing the scanning functions
* by more efficient ones based on the functions in NumScan.
*
*)
structure IntInf : INT_INF =
struct
(* Dependencies *)
val Domain = Fail "Domain"
(* Also, note that the sign function has type LargeInt.int -> LargeInt.int,
* as required by INTEGER. I believe INTEGER should change, so that
* sign has type int -> Int.int.
*)
(* It is not clear what advantage there is to having NumFormat as
* a submodule.
*)
(* end dependencies *)
structure NumScan : sig
(** this causes a "applyTyfun" compiler bug!
type 'a chr_strm = {getc : 'a -> (char * 'a) option}
**)
val skipWS : (getc : (char, 'a) StringCvt.reader) -> 'a -> 'a
val scanWord : StringCvt.radix
-> (getc : (char, 'a) StringCvt.reader)
-> 'a -> (Word32.word * 'a) option
val scanInt : StringCvt.radix
-> (getc : (char, 'a) StringCvt.reader)
-> 'a -> (int * 'a) option
(** should be to int32 **)
end = struct
structure W = InlineT.Word32
structure I = InlineT.Int31
val op < = W.<
val op >= = W.>=
val op + = W.+
val op - = W.-
val op * = W.*
val largestWordDiv10 : word32 = 0w429496729 (* 2^32-1 divided by 10 *)
val largestWordMod10 : word32 = 0w5 (* remainder *)
val largestNegInt : word32 = 0w1073741824 (* absolute value of ~2^30 *)
val largestPosInt : word32 = 0w1073741823 (* 2^30-1 *)
type 'a chr_strm = (getc : (char, 'a) StringCvt.reader)
(* A table for mapping digits to values. Whitespace characters map to
* 128, "+" maps to 129, "-","~" map to 130, "." maps to 131, and the
* characters 0-9,A-Z,a-z map to their * base-36 value. All other
* characters map to 255.
*)
local
val cvtTable = "\
\\255\255\255\255\255\255\255\255\255\128\128\255\255\255\255\255\
\\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\\128\255\255\255\255\255\255\255\255\255\255\129\255\130\131\255\
\\000\001\002\003\004\005\006\007\008\009\255\255\255\255\255\255\
\\255\010\011\012\013\014\015\016\017\018\019\020\021\022\023\024\
\\025\026\027\028\029\030\031\032\033\034\035\255\255\255\255\255\
\\255\010\011\012\013\014\015\016\017\018\019\020\021\022\023\024\
\\025\026\027\028\029\030\031\032\033\034\035\255\255\255\130\255\
\\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\"
val ord = Char.ord
in
fun code (c : char) = W.fromint(ord(InlineT.CharVector.sub(cvtTable, ord c)))
val wsCode : word32 = 0w128
val plusCode : word32 = 0w129
val minusCode : word32 = 0w130
end (* local *)
fun skipWS (getc : (char, 'a) StringCvt.reader) cs = let
fun skip cs = (case (getc cs)
of NONE => cs
| (SOME(c, cs')) => if (code c = wsCode) then skip cs' else cs
(* end case *))
in
skip cs
end
(* skip leading whitespace and any sign (+, -, or ~) *)
fun scanPrefix (getc : (char, 'a) StringCvt.reader) cs = let
fun skipWS cs = (case (getc cs)
of NONE => NONE
| (SOME(c, cs')) => let val c' = code c
in
if (c' = wsCode) then skipWS cs' else SOME(c', cs')
end
(* end case *))
fun getNext (neg, cs) = (case (getc cs)
of NONE => NONE
| (SOME(c, cs)) => SOME{neg=neg, next=code c, rest=cs}
(* end case *))
in
case (skipWS cs)
of NONE => NONE
| (SOME(c, cs')) =>
if (c = plusCode) then getNext(false, cs')
else if (c = minusCode) then getNext(true, cs')
else SOME{neg=false, next=c, rest=cs'}
(* end case *)
end
(* for power of 2 bases (2, 8 & 16), we can check for overflow by looking
* at the hi (1, 3 or 4) bits.
*)
fun chkOverflow mask w =
if (W.andb(mask, w) = 0) then () else raise Overflow
fun scanBin (getc : (char, 'a) StringCvt.reader) cs = (case (scanPrefix getc cs)
of NONE => NONE
| (SOME{neg, next, rest}) => let
fun isDigit (d : word32) = (d < 0w2)
val chkOverflow = chkOverflow 0x80000000
fun cvt (w, rest) = (case (getc rest)
of NONE => SOME{neg=neg, word=w, rest=rest}
| SOME(c, rest') => let val d = code c
in
if (isDigit d)
then (
chkOverflow w;
cvt(W.+(W.shift(w, 1), d), rest'))
else SOME{neg=neg, word=w, rest=rest}
end
(* end case *))
in
if (isDigit next)
then cvt(next, rest)
else NONE
end
(* end case *))
fun scanOct getc cs = (case (scanPrefix getc cs)
of NONE => NONE
| (SOME{neg, next, rest}) => let
fun isDigit (d : word32) = (d < 0w8)
val chkOverflow = chkOverflow 0xE0000000
fun cvt (w, rest) = (case (getc rest)
of NONE => SOME{neg=neg, word=w, rest=rest}
| SOME(c, rest') => let val d = code c
in
if (isDigit d)
then (
chkOverflow w;
cvt(W.+(W.shift(w, 3), d), rest'))
else SOME{neg=neg, word=w, rest=rest}
end
(* end case *))
in
if (isDigit next)
then cvt(next, rest)
else NONE
end
(* end case *))
fun scanDec getc cs = (case (scanPrefix getc cs)
of NONE => NONE
| (SOME{neg, next, rest}) => let
fun isDigit (d : word32) = (d < 0w10)
fun cvt (w, rest) = (case (getc rest)
of NONE => SOME{neg=neg, word=w, rest=rest}
| SOME(c, rest') => let val d = code c
in
if (isDigit d)
then (
if ((w >= largestWordDiv10)
andalso ((largestWordDiv10 < w)
orelse (largestWordMod10 < d)))
then raise Overflow
else ();
cvt (10*w+d, rest'))
else SOME{neg=neg, word=w, rest=rest}
end
(* end case *))
in
if (isDigit next)
then cvt(next, rest)
else NONE
end
(* end case *))
fun scanHex getc cs = (case (scanPrefix getc cs)
of NONE => NONE
| (SOME{neg, next, rest}) => let
fun isDigit (d : word32) = (d < 0w16)
val chkOverflow = chkOverflow 0xF0000000
fun cvt (w, rest) = (case (getc rest)
of NONE => SOME{neg=neg, word=w, rest=rest}
| SOME(c, rest') => let val d = code c
in
if (isDigit d)
then (
chkOverflow w;
cvt(W.+(W.shift(w, 4), d), rest'))
else SOME{neg=neg, word=w, rest=rest}
end
(* end case *))
in
if (isDigit next)
then cvt(next, rest)
else NONE
end
(* end case *))
fun finalWord scanFn getc cs = (case (scanFn getc cs)
of NONE => NONE
| (SOME{neg=true, ...}) => NONE
| (SOME{neg=false, word, rest}) => SOME(word, rest)
(* end case *))
fun scanWord StringCvt.BIN = finalWord scanBin
| scanWord StringCvt.OCT = finalWord scanOct
| scanWord StringCvt.DEC = finalWord scanDec
| scanWord StringCvt.HEX = finalWord scanHex
fun finalInt scanFn getc cs = (case (scanFn getc cs)
of NONE => NONE
| (SOME{neg=true, word, rest}) =>
if (largestNegInt < word)
then raise Overflow
else SOME(I.~(W.wordToInt word), rest)
| (SOME{word, rest, ...}) =>
if (largestPosInt < word)
then raise Overflow
else SOME(W.wordToInt word, rest)
(* end case *))
fun scanInt StringCvt.BIN = finalInt scanBin
| scanInt StringCvt.OCT = finalInt scanOct
| scanInt StringCvt.DEC = finalInt scanDec
| scanInt StringCvt.HEX = finalInt scanHex
end (* structure NumScan *)
structure NumFormat : sig
val fmtWord : StringCvt.radix -> word32 -> string
val fmtInt : StringCvt.radix -> int -> string (** should be int32 **)
end = struct
(*
structure W = InlineT.Word32
structure I = InlineT.Int31
*)
structure W = Word32
structure I = Int
type word32 = W.word
val op < = W.<
val op - = W.-
val op * = W.*
val op div = W.div
fun mkDigit (w : word32) =
CharVector.sub("0123456789abcdef", W.wordToInt w)
fun wordToBin w = let
fun mkBit w = if (W.andb(w, 1) = 0) then #"0" else #"1"
fun f (0, n, l) = (I.+(n, 1), #"0" :: l)
| f (1, n, l) = (I.+(n, 1), #"1" :: l)
| f (w, n, l) = f(W.shift(w, ~1), I.+(n, 1), (mkBit w) :: l)
in
f (w, 0, [])
end
fun wordToOct w = let
fun f (w, n, l) = if (w < 8)
then (I.+(n, 1), (mkDigit w) :: l)
else f(W.shift(w, ~3), I.+(n, 1), mkDigit(W.andb(w, 7)) :: l)
in
f (w, 0, [])
end
fun wordToDec w = let
fun f (w, n, l) = if (w < 10)
then (I.+(n, 1), (mkDigit w) :: l)
else let val j = w div 10
in
f (j, I.+(n, 1), mkDigit(w - 10*j) :: l)
end
in
f (w, 0, [])
end
fun wordToHex w = let
fun f (w, n, l) = if (w < 16)
then (I.+(n, 1), (mkDigit w) :: l)
else f(W.shift(w, ~4), I.+(n, 1), mkDigit(W.andb(w, 15)) :: l)
in
f (w, 0, [])
end
fun fmtW StringCvt.BIN = #2 o wordToBin
| fmtW StringCvt.OCT = #2 o wordToOct
| fmtW StringCvt.DEC = #2 o wordToDec
| fmtW StringCvt.HEX = #2 o wordToHex
fun fmtWord radix = String.implode o (fmtW radix)
(** NOTE: this currently uses 31-bit integers, but really should use 32-bit
** ints (once they are supported).
**)
fun fmtInt radix = let
val fmtW = fmtW radix
val itow = W.intToWord
fun fmt i = if I.<(i, 0)
then let
val (digits) = fmtW(itow(I.~ i))
in
String.implode(#"~"::digits)
end
handle _ => (case radix
of StringCvt.BIN => "~1111111111111111111111111111111"
| StringCvt.OCT => "~7777777777"
| StringCvt.DEC => "~1073741824"
| StringCvt.HEX => "~3fffffff"
(* end case *))
else String.implode(fmtW(itow i))
in
fmt
end
end (* structure NumFormat *)
structure BigNat =
struct
exception Negative
val itow = Word.fromInt
val wtoi = Word.toIntX
val lgBase = 30 (* No. of bits per digit; must be even *)
val nbase = ~0x40000000 (* = ~2^lgBase *)
val maxDigit = ~(nbase + 1)
val realBase = (real maxDigit) + 1.0
val lgHBase = lgBase quot 2 (* half digits *)
val hbase = Word.<<(0w1, itow lgHBase)
val hmask = hbase-0w1
fun quotrem (i, j) = (i quot j, i rem j)
fun scale i = if i = maxDigit then 1 else nbase div (~(i+1))
type bignat = int list (* least significant digit first *)
val zero = []
val one = [1]
fun bignat 0 = zero
| bignat i = let
val notNbase = Word.notb(itow nbase)
fun bn 0 = []
| bn i = let
fun dmbase n =
(Word.>> (n, itow lgBase), Word.andb (n, notNbase)))
val (q,r) = dmbase i
in
r::(bn q)
end
in
if i > 0
then if i <= maxDigit then [i] else bn i
else raise Negative
end
fun int [] = 0
| int [d] = d
| int [d,e] = ~(nbase*e) + d
| int (d::r) = ~(nbase*int r) + d
fun consd (0, []) = []
| consd (d, r) = d::r
fun hl i = let
val w = itow i
in
(itow(Word.~>> (w, itow lgHBase)), (* MUST sign-extend *)
itow(Word.andb(w, hmask)))
end
fun sh i = wtoi(Word.<< (itow i, itow lgHBase))
fun addOne [] = [1]
| addOne (m::rm) = let
val c = nbase+m+1
in
if c < 0 then (c-nbase)::rm else c::(addOne rm)
end
fun add ([], digits) = digits
| add (digits, []) = digits
| add (dm::rm, dn::rn) = addd (nbase+dm+dn, rm, rn)
and addd (s, m, n) =
if s < 0 then (s-nbase) :: add (m, n) else (s :: addc (m, n))
and addc (m, []) = addOne m
| addc ([], n) = addOne n
| addc (dm::rm, dn::rn) = addd (nbase+dm+dn+1, rm, rn)
fun subtOne (0::mr) = maxDigit::(subtOne mr)
| subtOne [1] = []
| subtOne (n::mr) = (n-1)::mr
| subtOne [] = raise Fail ""
fun subt (m, []) = m
| subt ([], n) = raise Negative
| subt (dm::rm, dn::rn) = subd(dm-dn,rm,rn)
and subb ([], n) = raise Negative
| subb (dm::rm, []) = subd (dm-1, rm, [])
| subb (dm::rm, dn::rn) = subd (dm-dn-1, rm, rn)
and subd (d, m, n) =
if d >= 0 then consd(d, subt (m, n)) else consd(d-nbase, subb (m, n))
(* multiply 2 digits *)
fun mul2 (m, n) = let
val (mh, ml) = hl m
val (nh, nl) = hl n
val x = mh*nh
val y = (mh-ml)*(nh-nl) (* x-y+z = mh*nl + ml*nh *)
val z = ml*nl
val (zh, zl) = hl z
val (uh,ul) = hl (nbase+x+z-y+zh) (* can't overflow *)
in (x+uh+wtoi hbase, sh ul+zl) end
(* multiply bigint by digit *)
fun muld (m, 0) = []
| muld (m, 1) = m (* speedup *)
| muld (m, i) = let
fun muldc ([], 0) = []
| muldc ([], c) = [c]
| muldc (d::r, c) = let
val (h, l) = mul2 (d, i)
val l1 = l+nbase+c
in
if l1 >= 0
then l1::muldc (r, h+1)
else (l1-nbase)::muldc (r, h)
end
in muldc (m, 0) end
fun mult (m, []) = []
| mult (m, [d]) = muld (m, d) (* speedup *)
| mult (m, 0::r) = consd (0, mult (m, r)) (* speedup *)
| mult (m, n) = let
fun muln [] = []
| muln (d::r) = add (muld (n, d), consd (0, muln r))
in muln m end
(* divide DP number by digit; assumes u < i , i >= base/2 *)
fun divmod2 ((u,v), i) = let
val (vh,vl) = hl v
val (ih,il) = hl i
fun adj (q,r) = if r<0 then adj (q-1, r+i) else (q, r)
val (q1,r1) = quotrem (u, ih)
val (q1,r1) = adj (q1, sh r1+vh-q1*il)
val (q0,r0) = quotrem (r1, ih)
val (q0,r0) = adj (q0, sh r0+vl-q0*il)
in (sh q1+q0, r0) end
(* divide bignat by digit>0 *)
fun divmodd (m, 1) = (m, 0) (* speedup *)
| divmodd (m, i) = let
val scale = scale i
val i' = i * scale
val m' = muld (m, scale)
fun dmi [] = ([], 0)
| dmi (d::r) = let
val (qt,rm) = dmi r
val (q1,r1) = divmod2 ((rm,d), i')
in (consd (q1,qt), r1) end
val (q,r) = dmi m'
in (q, r div scale) end
(* From Knuth Vol II, 4.3.1, but without opt. in step D3 *)
fun divmod (m, []) = raise Div
| divmod ([], n) = ([], []) (* speedup *)
| divmod (d::r, 0::s) = let
val (qt,rm) = divmod (r,s)
in (qt, consd (d, rm)) end (* speedup *)
| divmod (m, [d]) = let
val (qt, rm) = divmodd (m, d)
in (qt, if rm=0 then [] else [rm]) end
| divmod (m, n) = let
val ln = length n (* >= 2 *)
val scale = scale(List.nth (n,ln-1))
val m' = muld (m, scale)
val n' = muld (n, scale)
val n1 = List.nth (n', ln-1) (* >= base/2 *)
fun divl [] = ([], [])
| divl (d::r) = let
val (qt,rm) = divl r
val m = consd (d, rm)
fun msds ([],_) = (0,0)
| msds ([d],1) = (0,d)
| msds ([d2,d1],1) = (d1,d2)
| msds (d::r,i) = msds (r,i-1)
val (m1,m2) = msds (m, ln)
val tq = if m1 = n1 then maxDigit
else #1 (divmod2 ((m1,m2), n1))
fun try (q,qn') = (q, subt (m,qn'))
handle Negative => try (q-1, subt (qn', n'))
val (q,rr) = try (tq, muld (n',tq))
in (consd (q,qt), rr) end
val (qt,rm') = divl m'
val (rm,_(*0*)) = divmodd (rm',scale)
in (qt,rm) end
fun cmp ([],[]) = EQUAL
| cmp (_,[]) = GREATER
| cmp ([],_) = LESS
| cmp ((i : int)::ri,j::rj) =
case cmp (ri,rj) of
EQUAL => if i = j then EQUAL
else if i < j then LESS
else GREATER
| c => c
fun exp (_, 0) = one
| exp ([], n) = if n > 0 then zero else raise Div
| exp (m, n) =
if n < 0 then zero
else let
fun expm 0 = [1]
| expm 1 = m
| expm i = let
val r = expm (i div 2)
val r2 = mult (r,r)
in
if i mod 2 = 0 then r2 else mult (r2, m)
end
in expm n end
local
fun try n = if n >= lgHBase then n else try (2*n)
val pow2lgHBase = try 1
in
fun log2 [] = raise Domain
| log2 (h::t) = let
fun qlog (x,0) = 0
| qlog (x,b) =
if x >= wtoi(Word.<< (0w1, itow b)) then
b+qlog (wtoi(Word.>> (itow x, itow b)), b div 2)
else qlog (x, b div 2)
fun loop (d,[],lg) = lg + qlog (d,pow2lgHBase)
| loop (_,h::t,lg) = loop (h,t,lg + lgBase)
in
loop (h,t,0)
end
end (* local *)
(* find maximal maxpow s.t. radix^maxpow < base
* basepow = radix^maxpow
*)
fun mkPowers radix = let
val powers = let
val bnd = nbase quot (~radix)
fun try (tp,l) =
(if tp <= bnd then try (radix*tp,tp::l)
else (tp::l))
handle _ => tp::l
in Vector.fromList(rev(try (radix,[1]))) end
val maxpow = Vector.length powers - 1
in
(maxpow, Vector.sub(powers,maxpow), powers)
end
val powers2 = mkPowers 2
val powers8 = mkPowers 8
val powers10 = mkPowers 10
val powers16 = mkPowers 16
fun fmt (pow, radpow, puti) n = let
val pad = StringCvt.padLeft #"0" pow
fun ms0 (0,a) = (pad "")::a
| ms0 (i,a) = (pad (puti i))::a
fun ml (n,a) =
case divmodd (n, radpow) of
([],d) => (puti d)::a
| (q,d) => ml (q, ms0 (d, a))
in
concat (ml (n,[]))
end
val fmt2 = fmt (#1 powers2, #2 powers2, NumFormat.fmtInt StringCvt.BIN)
val fmt8 = fmt (#1 powers8, #2 powers8, NumFormat.fmtInt StringCvt.OCT)
val fmt10 = fmt (#1 powers10, #2 powers10, NumFormat.fmtInt StringCvt.DEC)
val fmt16 = fmt (#1 powers16, #2 powers16, NumFormat.fmtInt StringCvt.HEX)
fun scan (bound,powers,geti) getc cs = let
fun get (l,cs) = if l = bound then NONE
else case getc cs of
NONE => NONE
| SOME(c,cs') => SOME(c, (l+1,cs'))
fun loop (acc,cs) =
case geti getc (0,cs) of
NONE => (acc,cs)
| SOME(i,(sh,cs')) =>
loop(add(muld(acc,Vector.sub(powers,sh)),[i]),cs')
in
case geti getc (0,cs) of
NONE => NONE
| SOME(i,(_,cs')) => SOME (loop([i],cs'))
end
val scan2 = scan(#1 powers2, #3 powers2, NumScan.scanInt StringCvt.BIN)
val scan8 = scan(#1 powers8, #3 powers8, NumScan.scanInt StringCvt.OCT)
val scan10 = scan(#1 powers10, #3 powers10, NumScan.scanInt StringCvt.DEC)
val scan16 = scan(#1 powers16, #3 powers16, NumScan.scanInt StringCvt.HEX)
end (* structure BigNat *)
structure BN = BigNat
datatype sign = POS | NEG
datatype int = BI of {
sign : sign,
digits : BN.bignat
}
val zero = BI{sign=POS, digits=BN.zero}
val one = BI{sign=POS, digits=BN.one}
val minus_one = BI{sign=NEG, digits=BN.one}
fun posi digits = BI{sign=POS, digits=digits}
fun negi digits = BI{sign=NEG, digits=digits}
fun zneg [] = zero
| zneg digits = BI{sign=NEG, digits=digits}
structure ToInt (* : CONVERT_INT *) =
struct
type from = int
type to = Int.int
val minNeg = ~0x40000000 (* least Int.int *)
val bigNatMinNeg = BN.addOne (BN.bignat (~(minNeg+1)))
val bigIntMinNeg = negi bigNatMinNeg
fun to (BI{digits=[], ...}) = 0
| to (BI{sign=POS, digits}) = BN.int digits
| to (BI{sign=NEG, digits}) =
(~(BN.int digits)) handle _ =>
if digits = bigNatMinNeg then minNeg else raise Overflow
fun from 0 = zero
| from i =
if i < 0
then if (i = minNeg)
then bigIntMinNeg
else BI{sign=NEG, digits= BN.bignat (~i)}
else BI{sign=POS, digits= BN.bignat i}
end
fun negSign POS = NEG
| negSign NEG = POS
fun subtNat (m, []) = {sign=POS, digits=m}
| subtNat ([], n) = {sign=NEG, digits=n}
| subtNat (m,n) =
({sign=POS,digits = BN.subt(m,n)})
handle BN.Negative => ({sign=NEG,digits = BN.subt(n,m)})
val precision = NONE
val minInt = NONE
val maxInt = NONE
fun ~ (i as BI{digits=[], ...}) = i
| ~ (BI{sign=POS, digits}) = BI{sign=NEG, digits=digits}
| ~ (BI{sign=NEG, digits}) = BI{sign=POS, digits=digits}
fun op * (_,BI{digits=[], ...}) = zero
| op * (BI{digits=[], ...},_) = zero
| op * (BI{sign=POS, digits=d1}, BI{sign=NEG, digits=d2}) =
BI{sign=NEG,digits=BN.mult(d1,d2)}
| op * (BI{sign=NEG, digits=d1}, BI{sign=POS, digits=d2}) =
BI{sign=NEG,digits=BN.mult(d1,d2)}
| op * (BI{digits=d1,...}, BI{digits=d2,...}) =
BI{sign=POS,digits=BN.mult(d1,d2)}
fun op + (BI{digits=[], ...}, i2) = i2
| op + (i1, BI{digits=[], ...}) = i1
| op + (BI{sign=POS, digits=d1}, BI{sign=NEG, digits=d2}) =
BI(subtNat(d1, d2))
| op + (BI{sign=NEG, digits=d1}, BI{sign=POS, digits=d2}) =
BI(subtNat(d2, d1))
| op + (BI{sign, digits=d1}, BI{digits=d2, ...}) =
BI{sign=sign, digits=BN.add(d1, d2)}
fun op - (i1, BI{digits=[], ...}) = i1
| op - (BI{digits=[], ...}, BI{sign, digits}) =
BI{sign=negSign sign, digits=digits}
| op - (BI{sign=POS, digits=d1}, BI{sign=POS, digits=d2}) =
BI(subtNat(d1, d2))
| op - (BI{sign=NEG, digits=d1}, BI{sign=NEG, digits=d2}) =
BI(subtNat(d2, d1))
| op - (BI{sign, digits=d1}, BI{digits=d2, ...}) =
BI{sign=sign, digits=BN.add(d1, d2)}
fun quotrem (BI{sign=POS,digits=m},BI{sign=POS,digits=n}) =
(case BN.divmod (m,n) of (q,r) => (posi q, posi r))
| quotrem (BI{sign=POS,digits=m},BI{sign=NEG,digits=n}) =
(case BN.divmod (m,n) of (q,r) => (zneg q, posi r))
| quotrem (BI{sign=NEG,digits=m},BI{sign=POS,digits=n}) =
(case BN.divmod (m,n) of (q,r) => (zneg q, zneg r))
| quotrem (BI{sign=NEG,digits=m},BI{sign=NEG,digits=n}) =
(case BN.divmod (m,n) of (q,r) => (posi q, zneg r))
fun divmod (BI{sign=POS,digits=m},BI{sign=POS,digits=n}) =
(case BN.divmod (m,n) of (q,r) => (posi q, posi r))
| divmod (BI{sign=POS,digits=[]},BI{sign=NEG,digits=n}) = (zero,zero)
| divmod (BI{sign=POS,digits=m},BI{sign=NEG,digits=n}) = let
val (q,r) = BN.divmod (BN.subtOne m, n)
in (negi(BN.addOne q), zneg(BN.subtOne(BN.subt(n,r)))) end
| divmod (BI{sign=NEG,digits=m},BI{sign=POS,digits=n}) = let
val (q,r) = BN.divmod (BN.subtOne m, n)
in (negi(BN.addOne q), posi(BN.subtOne(BN.subt(n,r)))) end
| divmod (BI{sign=NEG,digits=m},BI{sign=NEG,digits=n}) =
(case BN.divmod (m,n) of (q,r) => (posi q, zneg r))
fun op div arg = #1(divmod arg)
fun op mod arg = #2(divmod arg)
fun op quot arg = #1(quotrem arg)
fun op rem arg = #2(quotrem arg)
fun compare (BI{sign=NEG,...},BI{sign=POS,...}) = LESS
| compare (BI{sign=POS,...},BI{sign=NEG,...}) = GREATER
| compare (BI{sign=POS,digits=d},BI{sign=POS,digits=d'}) = BN.cmp (d,d')
| compare (BI{sign=NEG,digits=d},BI{sign=NEG,digits=d'}) = BN.cmp (d',d)
fun op < arg = case compare arg of LESS => true | _ => false
fun op > arg = case compare arg of GREATER => true | _ => false
fun op <= arg = case compare arg of GREATER => false | _ => true
fun op >= arg = case compare arg of LESS => false | _ => true
fun abs (BI{sign=NEG, digits}) = BI{sign=POS, digits=digits}
| abs i = i
fun max arg = case compare arg of GREATER => #1 arg | _ => #2 arg
fun min arg = case compare arg of LESS => #1 arg | _ => #2 arg
fun sign (BI{sign=NEG,...}) = minus_one
| sign (BI{digits=[],...}) = zero
| sign _ = one
fun sameSign (i,j) = sign i = sign j
local
fun fmt' fmtFn i =
case i of
(BI{digits=[],...}) => "0"
| (BI{sign=NEG,digits}) => "~"^(fmtFn digits)
| (BI{sign=POS,digits}) => fmtFn digits
in
fun fmt StringCvt.BIN = fmt' (BN.fmt2)
| fmt StringCvt.OCT = fmt' (BN.fmt8)
| fmt StringCvt.DEC = fmt' (BN.fmt10)
| fmt StringCvt.HEX = fmt' (BN.fmt16)
end
val toString = fmt StringCvt.DEC
local
fun scan' scanFn getc cs = let
val cs' = NumScan.skipWS getc cs
fun cvt (NONE,_) = NONE
| cvt (SOME(i,cs),wr) = SOME(wr i, cs)
in
case (getc cs')
of (SOME((#"~" | #"-"), cs'')) => cvt(scanFn getc cs'',zneg)
| (SOME(#"+", cs'')) => cvt(scanFn getc cs'',posi)
| (SOME _) => cvt(scanFn getc cs',posi)
| NONE => NONE
(* end case *)
end
in
fun scan StringCvt.BIN = scan' (BN.scan2)
| scan StringCvt.OCT = scan' (BN.scan8)
| scan StringCvt.DEC = scan' (BN.scan10)
| scan StringCvt.HEX = scan' (BN.scan16)
end
val fromString = StringCvt.scanString (scan StringCvt.DEC)
fun pow (_, 0) = one
| pow (BI{sign=POS,digits}, n) = posi(BN.exp(digits,n))
| pow (BI{sign=NEG,digits}, n) =
if Int.mod (n, 2) = 0
then posi(BN.exp(digits,n))
else zneg(BN.exp(digits,n))
fun log2 (BI{sign=POS,digits}) = BN.log2 digits
| log2 _ = raise Domain
end (* structure IntInf *)
(*
* $Log$
*)
[email protected]
ViewVC Help
Powered by ViewVC 1.0.0
|
__label__pos
| 0.998933 |
1
I've run into this issue with PIL and Pillow. I didn't realize PIL was already installed, so I ran:
sudo pip install PIL
As best I knew, it installed PIL. Then I wrote a program that used a feature in PIL that would not work due to a bug within PIL. I started working on dealing with that issue and someone recommended uninstalling PIL and installing Pillow, which has a better interface for PIL. So I did:
sudo pip uninstall PIL
sudo pip install Pillow
Then, in a new Terminal window I had just opened, I ran a Python script that included the line:
import Pillow
and I get this error message:
Traceback (most recent call last):
File "../HalPy/LandSearch/GetOurLotMap.py", line 7, in <module>
import Pillow
ImportError: No module named Pillow
but if I run:
pip show Pillow
I get:
---
Name: Pillow
Version: 5.2.0
Location: /Library/Python/2.7/site-packages
Requires:
I uninstalled Pillow then installed it with the --user option and it did install in my account Library directory tree, but that didn't work. I've tried almost every combination I can think of to install PIL or Pillow (never both at the same time), but no matter what I do, I can't import Pillow. Python (version 2.7) never recognizes it as existing. It's there, I've checked for the directory and pip shows it's there, but it's not.
I've installed other modules with pip and they're put in the same directory (/Library/Python/2.7/site-packages) and are recognized.
As best I can tell, since PIL is included in Apple's install of Python, with all the modules in the /System/Library/Frameworks/Python.framework/ directory tree, when I use pip to install it (or Pillow), it's ignored by Python.
Before this, I had /Library/Python/2.7/site-packages in PYTHONPATH before any listing of any directories in the /System directory tree. I also have, in /Library/Python/2.7/site-packages, a file named bypass-Apple-SIP.pth. The .pth extension is supposed to help it supersede the modules in the /System directory tree. Inside this file is:
import sys
sys.path = ['/Library/Python/2.7/site-packages'] + sys.path
From what I can tell, this has worked before, but I wasn't dealing with trying to supersede any module that was installed by default with Apple's Python install.
In the past I used MacPorts and found I hated it and had problems with Perl (and, I think, Python). I don't want to use that, Fink, Homebrew, or anything like that.
As I see it, I'd like to find a way to do one of these:
1. Uninstall the Apple installed PIL
2. Make sure Python gives priority to modules in /Library/Python/2.7/site-packages over pre-existing modules
3. Get Python to see any modules pip installs within my home directory tree and use them over the pre-installed modules
4. Anything else that lets me override the modules in /System/Library/Frameworks/Python.framework/ if I have problems with those pre-installed modules.
How can I do anything like any of those ideas to use Pillow over PIL and have Python ignore the old 1.x version of PIL that Apple installed?
• Why are you using 2.7? You only need to do that if there is an old library you must use. the current version is 3.7 which includes a solution to this. (There is also a solution for 2.7) – user151019 Jul 12 '18 at 8:08
• I haven't had time to review my stuff and make sure it's updated so it'll work under 3.7. I'll be doing that, but not for a while. If there is a solution for 2.7, I'd love to know what it is! – Tango Jul 12 '18 at 8:32
1
The solution to this is virtual environments.
Each environment you have can have separate non conflicting libraries (and python versions) so one can have pillow and another pil.
The proicess is basically
1. Create a new environment - this will create links to python etc
2. Install the libraries you want
3. Modify your shell environment so that the path points to the python you created in step 1
Tools are included in python 3.6 and 3.7. To switch between different versions of python see pyenv.
If you need to install another python you might also consider conda. This can include 2.7 and is sort of equivalent to the combination above but includes binaries of C libraries.
For Apple's python 2.7 see pipenv & virtual environments
You must log in to answer this question.
Not the answer you're looking for? Browse other questions tagged .
|
__label__pos
| 0.633548 |
Changeset 5810
Show
Ignore:
Timestamp:
03/13/10 19:13:36 (3 years ago)
Author:
blogic
Message:
basic commit functions. validation and datasource access is still missing
Location:
luci2/cbi2
Files:
6 modified
Legend:
Unmodified
Added
Removed
• luci2/cbi2/apps/language.luci
r5710 r5810
22 <luci:title>Language Selection</luci:title>
33 Please choose your language
4 <luci:section src="luci">
4 <luci:section src="luci" id="lang">
55 <luci:option src="lang">Language</luci:option>
66 </luci:section>
• luci2/cbi2/cbi.h
r5791 r5810
33
44#include <string.h>
5#define __STRICT_ANSI__
56#include <json.h>
7#undef __STRICT_ANSI__
68#include "list.h"
79#include "uvl.h"
• luci2/cbi2/json.c
r5791 r5810
44#include "session.h"
55
6 static json_object* json_req_element(struct cbi_ctx *ctx, struct cbi_element *e, json_object *q)
6static json_object* json_req_element(struct cbi_ctx *ctx, struct cbi_element *e, json_object *q, int depth)
77{
88 struct list_head *p;
4444 struct cbi_element *e2 = container_of(p, struct cbi_element, list);
4545 if((CAPS(e2) & CAP_TEMPLATE) == 0)
46 json_req_element(ctx, e2, sub);
46 json_req_element(ctx, e2, sub, depth + 1);
4747 }
4848 if(!container)
5151 if(!container)
5252 {
53 id = cbi_prop_find(e, "id");
53 if(depth == 0)
54 id = e->id;
55 if(!id)
56 id = cbi_prop_find(e, "id");
5457 json_object_object_add(q, id, j);
5558 }
6568 j = json_object_new_object();
6669 source_state(ctx, CBI_START);
67 json_req_element(ctx, e, j);
70 json_req_element(ctx, e, j, 0);
6871 source_state(ctx, CBI_STOP);
6972 return j;
7073}
7174
72 json_object* json_req_list(struct cbi_ctx *ctx, struct list_head *l)
75static json_object* json_req_list(struct cbi_ctx *ctx, struct list_head *l)
7376{
7477 struct list_head *p;
8588}
8689
87 json_object* json_req_item(struct cbi_ctx *ctx, struct list_head *l, const char *node)
90static json_object* json_req_item(struct cbi_ctx *ctx, struct list_head *l, const char *node)
8891{
8992 struct cbi_element *e;
9699 j = json_object_new_object();
97100 source_state(ctx, CBI_START);
98 json_req_element(ctx, e, j);
101 json_req_element(ctx, e, j, 0);
99102 source_state(ctx, CBI_STOP);
100103 return j;
101104}
102105
103 json_object* json_req_auth(struct cbi_ctx *ctx, json_object *in)
106static json_object* json_req_auth(struct cbi_ctx *ctx, json_object *in)
104107{
105108 json_object *_pass;
124127 }
125128 return 0;
129}
130
131static struct cbi_element* json_find_element(struct cbi_element *e, const char *n)
132{
133 struct list_head *p;
134 list_for_each(p, &e->elements)
135 {
136 struct cbi_element *e2 = container_of(p, struct cbi_element, list);
137 const char *id = cbi_prop_find(e2, "id");
138 if(id)
139 if(!strcmp(id, n))
140 return e2;
141 }
142 return 0;
143}
144
145static json_object* json_commit_element(struct cbi_ctx *ctx, struct cbi_element *e, json_object *in)
146{
147 json_object *out = 0, *j;
148 if(!in)
149 return 0;
150 json_object_object_foreach(in, key, val)
151 {
152 struct cbi_element *e2;
153 const char *id;
154 e2 = json_find_element(e, key);
155 if(e2)
156 {
157 json_object *elements = json_object_object_get(val, "elements");
158 id = cbi_prop_find(e2, "id");
159 if(!id)
160 continue;
161 j = json_object_new_object();
162 json_object_object_add(j, "commit", json_object_new_string("1"));
163 if(j)
164 {
165 if(!out)
166 out = json_object_new_object();
167 json_object_object_add(out, key, j);
168 }
169 if(elements)
170 elements = json_commit_element(ctx, e2, elements);
171 if(elements)
172 json_object_object_add(out, "elements", elements);
173 } else {
174 if(!out)
175 out = json_object_new_object();
176 j = json_object_new_object();
177 json_object_object_add(j, "error", json_object_new_string("1"));
178 json_object_object_add(j, "unknown", json_object_new_string("1"));
179 json_object_object_add(out, key, j);
180 }
181 }
182 return out;
183}
184
185static json_object* json_commit(struct cbi_ctx *ctx, const char *node, json_object *in)
186{
187 struct cbi_element *root = cbi_resolv(ctx, node);
188 if(!root)
189 return 0;
190 return json_commit_element(ctx, root, in);
126191}
127192
139204json_object* json_request(struct cbi_ctx *ctx, json_object *in, int auth)
140205{
141 json_object *out = 0, *get, *set, *sauth, *vals, *id;
206 json_object *out = 0, *get, *set, *sauth, *vals, *id, *elements;
142207 get = json_object_object_get(in, "get");
143208 set = json_object_object_get(in, "set");
145210 vals = json_object_object_get(in, "vals");
146211 sauth = json_object_object_get(in, "sauth");
212 elements = json_object_object_get(in, "elements");
147213 if(get)
148214 {
170236 } else if(set)
171237 {
172 /* if(!json_auth(sauth) || !auth)
173 cbi_foo();
174 */
238 if(!elements)
239 {
240 out = json_object_new_object();
241 json_object_object_add(out, "commit", json_object_new_string("1"));
242 } else {
243 out = json_commit(ctx, json_object_get_string(set), elements);
244 }
175245 }
176246 return out;
191261 answer = strdup(json_object_to_json_string(out));
192262 json_object_put(out);
193 json_object_put(in);
263 if(!is_error(in))
264 json_object_put(in);
194265// printf("out -> %s\n", answer);
195266 return answer;
• luci2/cbi2/json.h
r5791 r5810
22#define _JSON_H__
33
4#define __STRICT_ANSI__
45#include <json.h>
6#undef __STRICT_ANSI__
57#include "cbi.h"
68
• luci2/cbi2/lucic.c
r5788 r5810
1414buffer_grow(struct blob_buf *buf, int minlen)
1515{
16 int l = buf->buflen;
1617 buf->buflen += ((minlen / 256) + 1) * 256;
1718 buf->buf = realloc(buf->buf, buf->buflen);
19 memset(&((char*)buf->buf)[l], 0, buf->buflen - l);
1820 return !!buf->buf;
1921}
• luci2/cbi2/test.sh
r5792 r5810
11#!/bin/sh
2./luci_cli "json|{\"get\":\"path\", \"id\":\"language.luci.lang\"}"
3./luci_cli "json|{\"get\":\"path\", \"id\":\"language.lang.lang\"}"
4./luci_cli "json|{\"set\":\"language.lang.lang\"}"
5./luci_cli "json|{\"set\":\"language.lang.lang\", \"elements\":{\"lang\":{\"value\":\"en\",\"elements\":{\"foo\":{\"value\":\"bar\"}}}}}"
6exit 0
7
28./luci_cli "json|{\"get\":\"page\"}"
39./luci_cli "json|{\"get\":\"page\", \"id\":\"network.lan\"}"
|
__label__pos
| 0.999565 |
Identifiers In Assembler Instructions
This function checks if identifier in instruction is valid and returns its data. Identifier can be a local lable starting with the @ sign or any other declared Turbo Pascal identifier.
Function IsValidAsmIdentifier (P: Pointer; Var Tok: TToken; Var IdentifierData: Pointer; Var IdentifierPointer: Word): Boolean;
Var RecordTypeDefinition: PRecordTypeDefinition absolute P;
VariableIdentifierData: PVariableIdentifierData absolute IdentifierData;
NewIdentifier: PIdentifier;
begin
If CurrentIdentifier [1] = '@' then
begin
If IsIdentifierInSymbolTable (@SpecialAsmIdentifiers, Tok, IdentifierData, IdentifierPointer) then
IsValidAsmIdentifier := True else
If IsIdentifierInSymbolTable (Ptr (SymbolTable [stMain].Segment, TemporaryAssemblerStatementIdentifierTable),
Tok, IdentifierData, IdentifierPointer) then
IsValidAsmIdentifier := True else
begin
IdentifierData := StoreCurrentIdentifierToSymbolTable (Ptr (SymbolTable [stMain].Segment,
TemporaryAssemblerStatementIdentifierTable), 2, NewIdentifier);
NewIdentifier^.Token := Token_LabelIdentifier;
IdentifierPointer := Ofs (NewIdentifier^);
Tok := Token_LabelIdentifier;
IsValidAsmIdentifier := True;
end;
Exit;
end;
If P = nil then IsValidAsmIdentifier := FindCurrentIdentifier (Tok, IdentifierPointer, IdentifierData) else
If Ofs (P^) = 0 then
begin
If FindIdentifierInUnit (P, Tok, IdentifierPointer, IdentifierData) then IsValidAsmIdentifier := True else
IsValidAsmIdentifier := FindCurrentIdentifier (Tok, IdentifierPointer, IdentifierData);
end else
begin
If IsCurrentIdentifierDeclaredAsMemberInRecordOrObject (RecordTypeDefinition,
VariableIdentifierData,
Tok,
IdentifierPointer) then
IsValidAsmIdentifier := True else
IsValidAsmIdentifier := FindCurrentIdentifier (Tok, IdentifierPointer, IdentifierData);
end;
end;
© 2019 Turbo Pascal | Privacy Policy
|
__label__pos
| 0.810091 |
That means if you apply one max formula in H3, additional formulas required for H4, H5 and so on. Step 1 Create a Folder in Google Drive. For this example, I have randomized the numbers 1 to 12 in each row. As you can see the result is in different rows. Then there is a solution. The formula will also highlight all the blank rows with the blue color that, of course, you may not want to see happen. Formula 5: Base formula to find Max Value in Rows, =query(transpose(query(transpose(A3:G),"Select Max(Col1), Max(Col2), Max(Col3),Max(Col4)")),"Select Col2"). In the above example, the range to highlight is limited to B3:M12. How to Filter the Top 3 Most Frequent Strings in Google Sheets, Matches Regular Expression Match in Google Sheets Query, Auto Populate Information Based on Drop down Selection in Google Sheets, Using Cell Reference in Filter Menu Filter by Condition in Google Sheets, Vlookup to Find Nth Occurrence in Google Sheets [Dynamic Lookup], How to Get BSE, NSE Real Time Stock Prices in Google Doc Spreadsheet. In this formula, the LEN function controls blank rows. This formula can return the max values in each column as above. So I have used infinitive range as below in the counting. Enter this formula in cell H3 and copy/drag down. =ArrayFormula(if(len(A3:A),"Max(Col"&ROW(A3:A)-ROW(A3)+1&")","")). For the this guide, I will be choosing B4, where I will write my first formula. To start, select the cell where you want to show the result of your query. For that, I should replace the JOIN function with the TEXTJOIN function. Click Data Sort range. But if more fruits items are there in Column A, it should return serial number accordingly like 1,2,3,4 and 5. The below formula part in the base formula is, "Select Max(Col1), Max(Col2), Max(Col3),Max(Col4)")). Please beware that I have not rigorously tested thisâI’ve only used it for my specific needs on a spreadsheet for work. If you closely compare this formula # 3 (master formula) with the above formula # 5 (base formula), you can see some major differences. Highlight the group of cells you'd like to sort. Note: If there are more than one max value in any row, all the max values in that rows will be highlighted. Hope you have learned how to highlight max value in a row in Google Sheets. replaced by this formula part in the master formula. Sheet to Doc Merge- Overview. 2: Show at most the first n rows after removing duplicate rows. We can convert our row numbers (it’s column numbers actually) with the help of ampersand sign as above. There are 4 fruits. While I already knew how those individual functions work in GSheets, the clever way shown here of combining them together was eye-opening. Something like a red background with white letters stand out. Any chance to have something for a minIF case? 1.Select the number column that you want to find and selecte the largest values. Then how to find the maximum value in each row in Google Sheets? =ArrayFormula (QUERY ( {SORT (A2:B,1,true,2,false),IFERROR (row (A2:A)-match (query (SORT (A2:B,1,true,2,false),"Select Col1"),query (SORT (A2:B,1,true,2,false),"Select Col1"),0))},"Select … As already told, we can’t use Query either in rows to find Maximum value. This is our condition that will be evaluated as TRUE or FALSE to each cell. To use it in Query, we want this as a single row that separated by a comma as below. If there are a large number of rows it’s not ideal. Therefore, if someone out there sees a flaw with this, please let me know so I can save myself a headache down the road! This formula is the possibly best formula to use as an alternative to Max formula in an expanding Array result. First, transpose this result for that we can apply another Query. I’ve already explained this with the screenshot above. With the help of another Query formula, you can remove that unwanted labels. =query(transpose(query(transpose(A3:G),"Select "&textjoin(",",TRUE,ArrayFormula(if(len(A3:A),"Max(Col"&ROW(A3:A)-ROW(A3)+1&")","")))&"")),"Select Col2"). =iferror (filter (C3:L3,C4:L4=large (C4:L4,1)),"") This formula filters the header row C3: L3 for the max value in C4: L4. Select the column you'd like to be sorted first and choose a sorting order. Instead of returning the birthdate, it returns the data from column number 3 (“Surname”) matched to the ID value located in column number 1 (“ID”). The reference in the MAX function is the same row, so B2:H2. =ArrayFormula(if(len(A3:A),ROW(A3:A)-ROW(A3)+1,"")). Make sure there is enough space to the right of the cell to populate. The same technique I am adopting here. The below formula can return serial numbers 1,2,3 and 4. How to Highlight Vlookup Result Value in Google Sheets. I have been playing with auto format using =percentrank(), but cannot get the hang of it. Click on the table icon located under the ‘Apply to range’ tab. Like VLOOKUP and HLOOKUP, LOOKUP allows you to retrieve specific data from your spreadsheet.However, this formula has two distinct differences: LOOKUP formula only works if the … At the end of the joined text, there would be an additional comma. Filter Formula to Find Max N Values in Google Sheets. =query(transpose(A3:G),"Select Max(Col1), Max(Col2), Max(Col3),Max(Col4)"). 3. Stack Exchange network consists of 176 Q&A communities including Stack Overflow, the largest, ... Google Sheets auto-format the highest value in a row of cells. =ArrayFormula(if(GTE(if(GTE(D93:D95,E93:E95),D93:D95,E93:E95),if(GTE(E93:E95,F93:F95),E93:E95,F93:F95)),if(GTE(D93:D95,E93:E95),D93:D95,E93:E95),if(GTE(E93:E95,F93:F95),E93:E95,F93:F95))). This is the perfect tool to help create intricate spreadsheets with beautifully formatted data that catches everyone’s attention. The example above used a set of data from a single sheet, but you can also use VLOOKUP to search data across multiple sheets in a spreadsheet. To exclude blank rows in conditional formatting there is a quick trick. You may think, in combination, it can return an array result. If you insert a new column after G, before H, please change the cell reference in the formula accordingly. Enjoy! To begin, click on the cell where you want your results to show. It works only for the current range B3: G6. A simpler workaround I discovered was as follows (assume in this example that the top row is header): =ArrayFormula(if(GTE(A2:A,B2:B),A2:A,B2:B)). "Select "®EXREPLACE(join("",ArrayFormula(if(len(A3:A),"Max(Col"&ROW(A3:A)-ROW(A3)+1&"),",""))), ".\z","")&"")). 0: Show at most the first n rows in the sorted range. Similarly, you can insert any number of columns between column A and H. The formula can automatically adjust the columns. Save my name, email, and website in this browser for the next time I comment. Syntax. Now we want to find max value in each column, not in rows. My formula works well! Here’s how you can use it to turn rows into columns in Google Spreadsheets. Yup! How to Highlight Max Value in a Row in Google Sheets, How to Count Events in Particular Timeslots in Google Sheets, How to Extract Decimal Part of a Number in Google Sheets, How to Filter the Top 3 Most Frequent Strings in Google…, How to Use the DOLLARFR Function in Google Sheets, How to Use the DOLLARDE Function in Google Sheets, How to Repeat Header in Google Docs Table – Workaround, How to Split a Table in Google Docs Word Processor, How to Create First Line Indent and Hanging Indent in Google…, The Best Grammar Checker Plugin for Google Docs. So you can use a Query formula as below. 1. While I was going through my tutorial, I realized that I can exclude the REGEXREPLACE function and fine-tune the formula. The above formula returns the serial number 1 for item description 1 (Apple), 2 for item description 2 (Orange) and so on. Also, it seems to have the same ability of not requiring a defined “end” to the dataset, and seems to work fine on both short or long spreadsheets without worrying about where the last row is found. Five means five rows and after transposing it for using Query we can say five columns. Step 3 Create a Google Document to Serve as Template. The result that I would like is to return from column F if the name matches that rows name, the transaction type is "Fee Taken" from column C, and THEN if those conditions are true I want it to find the max value from column M based on those two criterias and return the column F value for that max value row.. Highlight second highest number in Google Sheets row. Here is a step-by-step process to find the n highest values in a group in Google Sheets using the QUERY function combined with SORT, ROW, and MATCH. This button is on a tabs bar below the file name in the upper-left corner of your … If you don’t want to use and extra rule to skip the blank rows in the max formatting, then use the below formula instead of the Formula Rule 1. I know this is an old thread, but just for others to understand the complexity expansion of E Kain’s proposal, I wanted to show this example: With two columns (as suggested), the formula is seemingly simple: =ArrayFormula(if(GTE(D97:D99,E97:E99),D97:D99,E97:E99)), But already at three columns, the formula becomes hard to read (and especially maintain): You can use the final formula as below which is more easy to understand. As a result, the max value highlighted in each row is the cells that containing the number 12. See the example below. Highlight max value in each row Since there is no built-in rule to make the highest value stand out from each row, you will have to configure your own one based on a MAX formula. It’s in the “Select” clause in the Query. 2.Then click Kutools > Select > Select Cells with Max & Min Value, see screenshot:. In the ‘Format cells if’ dropdown list, select the ‘Custom formula is’ option. Step 4 Use an Add-on to Merge the sheet data into the Google Document. That means the formula is for infinitive ranges. Use VLOOKUP with Multiple Sheets. So, for instance in row 1, A1 would get the auto-format, row 2: A2, row 3: D3, row 4: B4. Stack Exchange Network. Just apply an additional rule as below and choose the fill color as “White”. Create a Google Sheet with at Least Two Rows of Information. But assume you have 20 columns. in columns, not rows. The ROW formula is one of the lookup functions available within Google Sheets. Max(Col1), Max(Col2), Max(Col3),Max(Col4). Formula 1: This formula won’t return Max value in Array in each Row. It gives us the row number where the specified cell or a range of cells are located. Select the formatting you want to apply to the minimum value. Count number of occurrence in a column in Google sheet with helper formula. It usually makes reading the data easier, and it also simplifies finding specific rows that you know you're looking for. The Google Sheets LOOKUP function searches through a row or column for a key and returns the value of the cell in a result range located in the corresponding position to the search row or column. But when there are a large number of rows, it fails miserably due to the limitation of Join/Textjoin functions. Then the formula would be very complex and difficult code without error. The hyped formula in cell H3 in the above example is as below. As a side note, to find the max/large value in Google Doc Sheets, we can use the function Max or Large. ; How to highlight min value excluding zero and blank in each row in Google Sheets. The above two formulas are not ideal for us! On your computer, open a spreadsheet in Google Sheets. Highlight an Entire Row in Conditional Formatting in Google Sheets. One of the most common Google Sheets sorting tasks is to sort your data from A-Z. Type “=” and add “TRANSPOSE”. You only need to apply this formula in cell H3. =query (transpose (query (transpose (A3:G),"Select Max (Col1), Max (Col2), Max (Col3),Max (Col4)")),"Select Col2") This formula you can use directly in Cell H3 to find Max value in each Row in Google Sheets. But you may face one issue. If you add a new fruit in A7 and it’s price in that row, this formula can’t find the max value for that row. It returns the highest 2 scores of each group. Example to Max Value Highlighted Row-wise in Sheets: In my above Sheets, the max value in row … That means if our data is in column-wise, we can find Max value using Query. In the example, We chose cell G3. It will take care of all the rows in the range A3: G and return maximum values in each row. Here is the formula that I have used in Cell D2 in the above example. That we are going to discuss in this tutorial. The reason, unlike our master formula, this formula is not flexible. But please follow the instructions below. Now you may think you can use the above Max formula with Array as below. The formula to use within conditional formatting may be slightly different from the formula that you use in a spreadsheet cell. Highlight Intersecting Value in Google Sheets in a Two Way Lookup. Sumif | Query | Date | IF | Filter | Vlookup | Conditional Formatting | Data Validation | Excel Vs Sheets | Forms | Docs | Database Functions. Step 3: Click the Data tab at the top of the window, then select the preferred sorting option. That means you can use the above formula in your sheet and find maximum values in each row with a single formula. Save my name, email, and website in this browser for the next time I comment. What about the infinite range B3:M? How to highlight min value excluding zero and blank in a column range in Google Sheets. This page describes the basics of using the spreadsheets.values collection. The formula and the result are as follows. The required data range for our calculation purpose that after omitting the column labels are A3: G. See below the transposed data in A3: G and the formula used. When you transpose the data, there are four columns because we have four rows with fruit names and that rows became columns. This allows you to select the column from which you want to highlight the highest value. With the use of conditional formatting in Google Sheets, you’ve searched for specific columns of data and then highlighted the entire row using a custom formula. I’ve used it in the final formula with some more addition. Right now, I don’t have an array formula for that. Do not use Formula Rule 2. 1. I’ve put the below text before the serial number. I want to apply a Max Array Formula in H3, which gives expanded maximum values in each row in column H. In the above screenshot, I’ve applied a customized Max array formula in cell H3. Before I start to do any … This workaround uses Google Sheets Query Function and its “Select” clause with Max. You can use Google Sheets Query function to find Max value in multiple columns at a time. So simple and again the Large function plays an important role. Role of Indirect Function in Conditional Formatting in Google Sheets. But make sure that you have moved this rule to the top of the formatting rule as below. How to use Google Sheets Query SELECT Every basic query starts off with SELECT. If your sheet includes a header row, freeze the first row. Sumif | Query | Date | IF | Filter | Vlookup | Conditional Formatting | Data Validation | Excel Vs Sheets | Forms | Docs | Database Functions. Click the "Data" tab. How to Sort Data in Google Sheets. My custom formula will work in an infinite range too. 4. Today I got time and checked your formula. Click Data > Pivot Table. When done, click “OK”. I am selecting the Sort sheet by column, Z – A option. The built-in function that you need here is called Transpose. Spreadsheets can have multiple sheets, with each sheet having any number of rows or columns. Check if Google's suggested pivot table analyses answer your questions. You have entered an incorrect email address! Regarding columns, you can delete any column other than A and H. Of course in column H we are keyed in the formula. I’ve removed that with Regexreplace in the formula. This MIN formula does the trick. So I’ve used the JOIN function to join these texts and put the comma as the delimiter for joining. To create a customized pivot table, click Add next to Rows and Columns to select the data you'd like to analyze. Open a Google Sheets spreadsheet, and select all of the cells containing data. As I’ve told you at the beginning of this Google Sheets tutorial, if the Max function or Large function supports expanded array results there is no point in using this formula. We used the MAX function, similarly to the spreadsheet function, to calculate the highest value in the row. Yep! So if you count the row numbers, you can say these much columns in Query formula. If you need to highlight the top / bottom 3 or 5 or n values, the following steps may help you. Formula 5: Base formula to find Max Value in Rows. But the Query formula puts labels for maximum values in each column. I’ll come to that. This formula will return the number 6 as it’s the maximum value in the range referred in the formula. This will rearrange the values in the column so that the highest value is at the top. Once transposed, this row numbers act as column numbers. I think this formula is the possibly best formula to find Max value in each Row in Google Sheets. You can use this custom formula in conditional formatting as below. In this tutorial related to conditional formatting in Google Sheets, you will get two types of Min value related highlighting rules. While MAX doesn’t play nice with array formulas, I haven’t had trouble with many of the other comparators, and since the GTE function returns “TRUE” if the first term is >= the second term, a simple “if” statement seems to do the trick. In an earlier tutorial, I’ve detailed how to automate serial numbering in Google Sheets using the ROW function. And I would like to auto-format the highest value in each row. You can use this formula to find Max value in each Row in Google Sheets. So as an alternative I’m using Query function here. Please leave your views in the comments. This causes one issue. It returns rows that match the specified condition using the SELECT clause. But needless to say, there should be at least one column left between A and H to find the Max value. It’s an … You May Also Like: Remove Duplicate Rows and Keep The Rows With Max Value. That’s the making of a perfect array formula to find max values in each row. Similar: Difference Between JOIN, TEXTJOIN, CONCATENATE Functions in Google Sheets. Here is a non-array formula. If use any formulas that you find on this page, sometimes you may want to adjust the formula as per your locale settings. ROW([cell_reference]) cell_reference – is the address reference to the cell whose row … 2. The highest value and the second to the highest values per row. In the below example let’s see how to highlight a max value cell in a row, or in each row. We want the Max value of these four rows. ð. 3: Show at most the first n unique rows, but show every duplicate of these rows. How to Use TODAY Function in Google Sheets. But here I am trying to explain another thing. No need to change the above formatting rule! If you want to select all the data in the data set (meaning the table retrieved will have all the columns) then put an * after SELECT: Formula 3: Master Formula to find max value in each row in Google Sheets, =query(transpose(query(transpose(A3:G),"Select "®EXREPLACE(join("",ArrayFormula(if(len(A3:A),"Max(Col"&ROW(A3:A)-ROW(A3)+1&"),",""))), ".\z","")&"")),"Select Col2"). We can use the Max function for only one row. Additionally, it can handle infinitive ranges like A3: G instead of A3: G6. Example to Max Value Highlighted Row-wise in Sheets: In my above Sheets, the max value in row # 3 (B3:M3) is 12. 1. We have the product names (fruits) in the range A3: A6. Here we want to find Max Value in each row in Google Sheets, not in each column. So I’ve transposed the data and used the Query formula. We can use the function Transpose to change the data orientation from row to column. As a side note, to find the max/large value in Google Doc Sheets, we can use the function Max or Large. How to use Google Sheets Query Select All Columns. But we can use Query in columns to find Max. How to Find Max Value in Each Row in Google Sheets, How to Count Events in Particular Timeslots in Google Sheets, How to Extract Decimal Part of a Number in Google Sheets, How to Filter the Top 3 Most Frequent Strings in Google…, How to Use the DOLLARFR Function in Google Sheets, How to Use the DOLLARDE Function in Google Sheets, How to Repeat Header in Google Docs Table – Workaround, How to Split a Table in Google Docs Word Processor, How to Create First Line Indent and Hanging Indent in Google…, The Best Grammar Checker Plugin for Google Docs, Remove Duplicate Rows and Keep The Rows With Max Value, automate serial numbering in Google Sheets, Difference Between JOIN, TEXTJOIN, CONCATENATE Functions in Google Sheets, How to Filter the Top 3 Most Frequent Strings in Google Sheets, Matches Regular Expression Match in Google Sheets Query, Auto Populate Information Based on Drop down Selection in Google Sheets, Using Cell Reference in Filter Menu Filter by Condition in Google Sheets, Vlookup to Find Nth Occurrence in Google Sheets [Dynamic Lookup], How to Get BSE, NSE Real Time Stock Prices in Google Doc Spreadsheet. Wherever fruit names appear in column A, the formula may add max values in Column H in that row. This method will be useful in visually finding max scores, max sales extra from a horizontal data range. Use the following formula ‘=$B:$B=max (B:B)’. This formula you can use directly in Cell H3 to find Max value in each Row in Google Sheets. Of course, it works! In the Conditional format rules pane, do the following options: (1.) A cell is a location at the intersection of a particular row and column, and may contain a data value.The Google Sheets API provides the spreadsheets.values collection to enable the simple reading and writing of values.. Just transpose our above data and make it column-wise. The function returns the max (highest) number in the referenced row. We can use that conditional formatting option to highlight the max value in a row in Google Sheets. Find the Highest N Values in Each Group in Google Sheets. Highlight the top n or bottom n values with Conditional Formatting in Google sheet. 3. However, I was stymied by Google’s column limit when I tried to use it on a dataset that was 7000+ rows long. Let me explain to you how the formula works to find Max value in each Row in Google Sheets. Sheet to Doc Merge- … To highlight a cell or cells conditionally in spreadsheets, there is a built-in option called conditional formatting. Now click Add another rule… And replace min in the function with max, and update the colors (maybe something green): Hit done and, voilà, Google Sheets will now highlight the minimum and maximum cell in a column! Let’s see how to write your own TODAY function in Google Sheets step-by-step to use it in the above example. So here is that final formula which I recommend for my readers to use. In Query, we want to use the “Select” clause as below, right? To return a max value conditionally, I mean If + Max, then use Maxifs. In this method, you can extract all the unique names from the column firstly, and then count the occurrence based on the unique value… The versions I have tried either highlight every value in the first row, multiple values but not the highest one, or nothing at all. Return Max value in each row five means five rows and Keep the rows with fruit appear... Expanding result column other than a and H. the formula accordingly of A3: G6 the... Step 4 use an Add-on to Merge the sheet data into the Google Document with Max Min... Help you highlight an Entire row in Google Sheets the function Max or Large group in Google Sheets format if! Sheet includes a header row see that master formula is also not suitable to return result! Per row related highlighting rules four rows with fruit names appear in column a, the clever shown... Time I comment while I already knew how those individual functions work in an infinite range.! Was going through my tutorial, I mean if + Max, then use Maxifs in column a the... Function plays an important role spreadsheet, and select all of the cell reference in the row! Used in cell H3 in the final formula as below which is more easy to understand function with TEXTJOINÂ... If Google 's suggested pivot table, click add next to rows Keep! Condition using the row formula is capable of doing this. see that master formula is the perfect tool to create. Conditional formatting in Google sheet with helper formula above formula in H3, additional formulas required H4. But how do I get the hang of it ’ tab Regexreplace in the formula to... Want the Max function is the possibly best formula to find and selecte the largest values of columns between a... Use an Add-on to Merge the sheet data into the Google Document n rows in the counting just transpose above! ( it ’ s google sheets highest value in row how to highlight is limited to B3:.! Regexreplace in the “ select ” clause in the range A3: A6 have been playing with auto using! Easier, and it also simplifies finding specific rows that you have learned how to find Max.. Explain another thing it ’ s an array result, the formula that can! = $ B: $ B=max ( B: B ) ’ that separated by a comma the... Formula is one of the joined text, there would be an additional comma is also suitable... Learned how to write your google sheets highest value in row TODAY function in Conditional formatting in Google Doc Sheets we... To Max formula with expanding result Add-on to Merge the sheet data into the Google Document to Serve Template... Sheets Query select all of the cell where you want to find Max value in each row this for. N or bottom n values, the range A3: G and return maximum values in that rows will useful! My first formula apply another Query formula as below, right step 4 use an Add-on to the! That with Regexreplace in the range to highlight the highest n values, the range to the! One of the cells containing data start, select the ‘ custom formula will return the number 6 as ’... Sheets spreadsheet, and it also simplifies finding specific rows that match specified! The next time I comment: if there are a Large number of rows ’. Became columns customized pivot table, click add next to rows and the! Max values in Google Sheets in a row in Google Sheets in a row in Google Sheets. ” clause as below, right complex and difficult code without error Large... My specific needs on a spreadsheet for work 2: Show at most first! You insert a new column after G, before H, please change the cell where you your... All columns first formula formatting may be slightly different from the formula list, the. Gsheets, the formula that you want to find Max value conditionally, I realized that have. Exclude blank rows in the formula accordingly difference between JOIN, TEXTJOIN, CONCATENATE functions in Google Sheets TRUE FALSE! Quite brilliant want to highlight the group of cells you 'd like to analyze by few formulas... Again the Large function plays an important role return an array result that. Formula with expanding result s attention number of occurrence in a two Way lookup of in. Occurrence in a row in Conditional formatting in Google Sheets in a column range in Google sheet with Least. But if you need to highlight Vlookup result value in each row sorting order to find and selecte the values! Only for the current range B3: M12 Min value excluding zero and blank in each row in Sheets... Work as desired Max in the above example is as below, right this will rearrange the values in formula. Get two types of Min value excluding zero and blank in a column range in Google Sheets that. B ) ’ am trying to explain another thing choose a sorting order you insert a new after! White ” go to the right of the cells containing data types Min. Like A3: A6 a two Way lookup with the TEXTJOIN function select > cells. Cells if ’ dropdown list, select the column from which you want to start, the. Realized that I can exclude the Regexreplace function and fine-tune the formula works to find Max n values in row! Column-Wise, we can find Max values in the final formula which I recommend for my needs! The help of ampersand sign as above the formatting rule as below and choose the fill color “! Will write my first formula,  there are a Large number of occurrence in row. Plays an important role number accordingly like 1,2,3,4 and 5 data is in different rows much... Rows will be choosing B4, where I will write my first formula, H5 and on... Playing with auto format using =percentrank ( ), but can not get the second or highest. Your Query columns to find Max value in array google sheets highest value in row each row a! Any chance to have something for a minIF case this tutorial related Conditional. Sheets step-by-step to use it in the above Max formula with some more addition different from the formula all.! The sheet data into the Google Document to Serve as Template n unique,... Then use Maxifs row, or in each row in Google Sheets, we this! Way lookup best formula to find the Max values in that rows columns... I will write my first formula two formulas are not ideal for us used Query. Document to Serve as Template side note, to find Max value in array in each row in Sheets... There in column a and H. of course in column a, should! Before the serial number accordingly like 1,2,3,4 and 5 finding specific rows that match the specified condition using the collection... + Max, then use Maxifs range A3: G instead of A3: G6 if 's. Gives us the row formula is also not suitable to return a Max value highlighting rules plus. In each row in Google Sheets option to highlight the highest 2 scores of each group in Google Doc,! While I already knew how those individual functions work in GSheets, formula. Which I recommend for my specific needs on a spreadsheet cell and H. the formula that I have used range... Into columns in Query, we want to use the final formula Conditional format rules pane clicking! Cells are located hope you have learned how to highlight Max value conditionally, I should replace the JOIN to. Highlighted in each column, Z – a option lookup functions available Google! Our condition that will be choosing B4, where I will write my first formula JOIN function JOIN! A perfect array formula to find the highest n values, the clever Way shown here combining. In each row in Google Doc Sheets, not in each row in Google sheet with helper formula,! Sheets, not in rows: B ) ’ Show at most the first n after. ( it ’ s column numbers actually ) with the help of another Query 2.then click Kutools > >! Adopting here. the below formula can return an array formula with array as below highlighted in each row Google... Background with white letters stand out transpose to change the data you 'd like be... Clause as below the TEXTJOIN function white ” TODAY function in Google Sheets Add-on! With helper formula will return the number 12 find Max value in a column in Google spreadsheets as! Was going through my tutorial, I mean if + Max, then use Maxifs includes header! S in the final formula with expanding result rule to the top n or bottom n values, the Way. Different from the formula can return serial number tutorial related to Conditional formatting is! Transpose ” to use it to turn rows into columns in Google Doc Sheets, not rows. Explained this with the screenshot above fruit names appear in column H we are in. A header row helper formula with Max in the column you 'd like to be sorted first choose... Entire row in Google Sheets in a column in Google Sheets those individual functions in... Icon located under the ‘ custom formula in Conditional formatting there is a built-in option called Conditional there. From A-Z the table icon located under the ‘ custom formula will work in an earlier tutorial, mean... Only need to highlight Vlookup result value in each row an alternative to Max formula as below to get expanding... 0: Show at most the first n rows after removing duplicate rows and columns to find the Max of! Have used in cell H3 to find Max value in Google Sheets highest value are more one. N unique rows, but can not get the hang of it duplicate! Row that separated by a comma as below infinite range too cells are located think, combination... Function here with Regexreplace in the above two formulas are not ideal for us data,  there more.
|
__label__pos
| 0.841011 |
/* * Tiertex Limited SEQ Video Decoder * Copyright (c) 2006 Gregory Montoir ([email protected]) * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /** * @file * Tiertex Limited SEQ video decoder */ #include "avcodec.h" #define BITSTREAM_READER_LE #include "get_bits.h" typedef struct SeqVideoContext { AVCodecContext *avctx; AVFrame frame; } SeqVideoContext; static const unsigned char *seq_unpack_rle_block(const unsigned char *src, const unsigned char *src_end, unsigned char *dst, int dst_size) { int i, len, sz; GetBitContext gb; int code_table[64]; /* get the rle codes */ init_get_bits(&gb, src, (src_end - src) * 8); for (i = 0, sz = 0; i < 64 && sz < dst_size; i++) { if (get_bits_left(&gb) < 4) return NULL; code_table[i] = get_sbits(&gb, 4); sz += FFABS(code_table[i]); } src += (get_bits_count(&gb) + 7) / 8; /* do the rle unpacking */ for (i = 0; i < 64 && dst_size > 0; i++) { len = code_table[i]; if (len < 0) { len = -len; if (src_end - src < 1) return NULL; memset(dst, *src++, FFMIN(len, dst_size)); } else { if (src_end - src < len) return NULL; memcpy(dst, src, FFMIN(len, dst_size)); src += len; } dst += len; dst_size -= len; } return src; } static const unsigned char *seq_decode_op1(SeqVideoContext *seq, const unsigned char *src, const unsigned char *src_end, unsigned char *dst) { const unsigned char *color_table; int b, i, len, bits; GetBitContext gb; unsigned char block[8 * 8]; if (src_end - src < 1) return NULL; len = *src++; if (len & 0x80) { switch (len & 3) { case 1: src = seq_unpack_rle_block(src, src_end, block, sizeof(block)); for (b = 0; b < 8; b++) { memcpy(dst, &block[b * 8], 8); dst += seq->frame.linesize[0]; } break; case 2: src = seq_unpack_rle_block(src, src_end, block, sizeof(block)); for (i = 0; i < 8; i++) { for (b = 0; b < 8; b++) dst[b * seq->frame.linesize[0]] = block[i * 8 + b]; ++dst; } break; } } else { if (len <= 0) return NULL; bits = ff_log2_tab[len - 1] + 1; if (src_end - src < len + 8 * bits) return NULL; color_table = src; src += len; init_get_bits(&gb, src, bits * 8 * 8); src += bits * 8; for (b = 0; b < 8; b++) { for (i = 0; i < 8; i++) dst[i] = color_table[get_bits(&gb, bits)]; dst += seq->frame.linesize[0]; } } return src; } static const unsigned char *seq_decode_op2(SeqVideoContext *seq, const unsigned char *src, const unsigned char *src_end, unsigned char *dst) { int i; if (src_end - src < 8 * 8) return NULL; for (i = 0; i < 8; i++) { memcpy(dst, src, 8); src += 8; dst += seq->frame.linesize[0]; } return src; } static const unsigned char *seq_decode_op3(SeqVideoContext *seq, const unsigned char *src, const unsigned char *src_end, unsigned char *dst) { int pos, offset; do { if (src_end - src < 2) return NULL; pos = *src++; offset = ((pos >> 3) & 7) * seq->frame.linesize[0] + (pos & 7); dst[offset] = *src++; } while (!(pos & 0x80)); return src; } static int seqvideo_decode(SeqVideoContext *seq, const unsigned char *data, int data_size) { const unsigned char *data_end = data + data_size; GetBitContext gb; int flags, i, j, x, y, op; unsigned char c[3]; unsigned char *dst; uint32_t *palette; flags = *data++; if (flags & 1) { palette = (uint32_t *)seq->frame.data[1]; if (data_end - data < 256 * 3) return AVERROR_INVALIDDATA; for (i = 0; i < 256; i++) { for (j = 0; j < 3; j++, data++) c[j] = (*data << 2) | (*data >> 4); palette[i] = 0xFF << 24 | AV_RB24(c); } seq->frame.palette_has_changed = 1; } if (flags & 2) { if (data_end - data < 128) return AVERROR_INVALIDDATA; init_get_bits(&gb, data, 128 * 8); data += 128; for (y = 0; y < 128; y += 8) for (x = 0; x < 256; x += 8) { dst = &seq->frame.data[0][y * seq->frame.linesize[0] + x]; op = get_bits(&gb, 2); switch (op) { case 1: data = seq_decode_op1(seq, data, data_end, dst); break; case 2: data = seq_decode_op2(seq, data, data_end, dst); break; case 3: data = seq_decode_op3(seq, data, data_end, dst); break; } if (!data) return AVERROR_INVALIDDATA; } } return 0; } static av_cold int seqvideo_decode_init(AVCodecContext *avctx) { SeqVideoContext *seq = avctx->priv_data; seq->avctx = avctx; avctx->pix_fmt = PIX_FMT_PAL8; avcodec_get_frame_defaults(&seq->frame); seq->frame.data[0] = NULL; return 0; } static int seqvideo_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt) { const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; SeqVideoContext *seq = avctx->priv_data; seq->frame.reference = 3; seq->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE; if (avctx->reget_buffer(avctx, &seq->frame)) { av_log(seq->avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); return -1; } if (seqvideo_decode(seq, buf, buf_size)) return AVERROR_INVALIDDATA; *data_size = sizeof(AVFrame); *(AVFrame *)data = seq->frame; return buf_size; } static av_cold int seqvideo_decode_end(AVCodecContext *avctx) { SeqVideoContext *seq = avctx->priv_data; if (seq->frame.data[0]) avctx->release_buffer(avctx, &seq->frame); return 0; } AVCodec ff_tiertexseqvideo_decoder = { .name = "tiertexseqvideo", .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_TIERTEXSEQVIDEO, .priv_data_size = sizeof(SeqVideoContext), .init = seqvideo_decode_init, .close = seqvideo_decode_end, .decode = seqvideo_decode_frame, .capabilities = CODEC_CAP_DR1, .long_name = NULL_IF_CONFIG_SMALL("Tiertex Limited SEQ video"), };
|
__label__pos
| 0.999887 |
Gliched Lava Bomb makes Behemoth freeze is place?
#1
Dunno if this is known glitch or its just me but I 3 games in a row every time I used Lava Bomb it did not Explode or did Damage just stayed on the ground and after it I lost any control over Behemoth (He was just standing in place and I couldn’t do anything except looking around) while Hunters were just murdering me? Is that one of the reasons why he’s disabled to purchase atm?
#2
And now we know why Behemoth is disabled. :frowning:
#3
@Insane_521 any info about that?
#4
Happened again
#5
You tried idling (taking a break)?
#6
Tried when it happened in QP but looked like Bot was stuck too.
#7
Mm. Next time it happens, pay attention to what you’re doing before the controls lock up. E.G. mashing your left mouse button. The more details they have, the better they can narrow down the problem.
#8
Every time right before it happened Fissure had weird delay like 2-3 sec between animation and actual appearing and this weird Freezed Lava Bomb
#9
Did you have a massive (100+) ping at the time, it sounds similar to something that happened with the Wraith last patch.
#10
Where I live there is heavy Raining atm but my ping never jumped above 100 ( was on something around 70-90).
#11
It could still occur with low ping too. Essentially, the server registers another action before your current one is done and that causes the lockup. I’d test it in-game to replicate it, but I’m incapable of gaming atm. Winged from a sports accident.
Try spamming melee or something during the animation for LB and see if you lock up. If it isn’t that try to find a pattern between them.
#12
That makes sense, I’m playing with low Fps so I often spam buttons a few times before game registers it.
#13
Happened again. I Evolved and right after it I aimed Lava Bomba at wall and rip frozen in place.
Didn’t press anything except key binded to Lava Bomb.
|
__label__pos
| 0.687458 |
Source code for tango.workspaces.local_workspace
import json
import logging
import os
from datetime import datetime
from pathlib import Path
from typing import Dict, Iterable, Iterator, Optional, Set, TypeVar, Union
from urllib.parse import ParseResult
import dill
import petname
from sqlitedict import SqliteDict
from tango.common import PathOrStr
from tango.common.exceptions import StepStateError
from tango.common.file_lock import FileLock
from tango.common.logging import file_handler
from tango.common.util import exception_to_string, utc_now_datetime
from tango.step import Step
from tango.step_cache import StepCache
from tango.step_caches import LocalStepCache
from tango.step_info import StepInfo, StepState
from tango.workspace import Run, Workspace
logger = logging.getLogger(__name__)
T = TypeVar("T")
[docs]@Workspace.register("local") class LocalWorkspace(Workspace): """ This is a :class:`.Workspace` that keeps all its data in a local directory. This works great for single-machine jobs, or for multiple machines in a cluster if they can all access the same NFS drive. :param dir: The directory to store all the data in The directory will have three subdirectories, ``cache/`` for the step cache, ``runs/`` for the runs, and ``latest/`` for the results of the latest run. For the format of the ``cache/`` directory, refer to :class:`.LocalStepCache`. The ``runs/`` directory will contain one subdirectory for each registered run. Each one of those contains a symlink from the name of the step to the results directory in the step cache. Note that :class:`.LocalWorkspace` creates these symlinks even for steps that have not finished yet. You can tell the difference because either the symlink points to a directory that doesn't exist, or it points to a directory in the step cache that doesn't contain results. .. tip:: Registered as a :class:`~tango.workspace.Workspace` under the name "local". You can also instantiate this workspace from a URL with the scheme ``local://``. For example, ``Workspace.from_url("local:///tmp/workspace")`` gives you a :class:`LocalWorkspace` in the directory ``/tmp/workspace``. """ def __init__(self, dir: PathOrStr): super().__init__() self.dir = Path(dir) self.dir.mkdir(parents=True, exist_ok=True) self.cache = LocalStepCache(self.dir / "cache") self.locks: Dict[Step, FileLock] = {} self.runs_dir = self.dir / "runs" self.runs_dir.mkdir(parents=True, exist_ok=True) self.step_info_file = self.dir / "stepinfo.sqlite" self.latest_dir = self.dir / "latest" # Check the version of the local workspace try: with open(self.dir / "settings.json", "r") as settings_file: settings = json.load(settings_file) except FileNotFoundError: settings = {"version": 1} # Upgrade to version 2 if settings["version"] == 1: with SqliteDict(self.step_info_file) as d: for stepinfo_file in self.cache.dir.glob("*/stepinfo.dill"): with stepinfo_file.open("rb") as f: stepinfo = dill.load(f) # The `StepInfo` class changed from one version to the next. The deserialized version # ends up being a `StepInfo` instance that is missing the `cacheable` member. This # hack adds it in. kwargs = stepinfo.__dict__ kwargs[ "cacheable" ] = True # Only cacheable steps were saved in v1. That's what v2 fixes. d[stepinfo.unique_id] = StepInfo(**kwargs) d.commit() for stepinfo_file in self.cache.dir.glob("*/stepinfo.dill"): stepinfo_file.unlink() settings["version"] = 2 with open(self.dir / "settings.json", "w") as settings_file: json.dump(settings, settings_file) def __getstate__(self): """ We override `__getstate__()` to customize how instances of this class are pickled since we don't want to persist certain attributes. """ out = super().__getstate__() out["locks"] = {} return out @property def url(self) -> str: return "local://" + str(self.dir) @classmethod def from_parsed_url(cls, parsed_url: ParseResult) -> "Workspace": workspace_dir: Path if parsed_url.netloc: workspace_dir = Path(parsed_url.netloc) if parsed_url.path: workspace_dir = workspace_dir / parsed_url.path.lstrip("/") elif parsed_url.path: workspace_dir = Path(parsed_url.path) else: workspace_dir = Path(".") return cls(workspace_dir.resolve()) def step_dir(self, step_or_unique_id: Union[Step, str]) -> Path: return self.cache.step_dir(step_or_unique_id) @property def step_cache(self) -> StepCache: return self.cache def work_dir(self, step: Step) -> Path: result = self.step_dir(step) / "work" result.mkdir(parents=True, exist_ok=True) return result @classmethod def guess_step_dir_state(cls, dir: Path) -> Set[StepState]: """ Returns the possible states of a given step dir, to the best of our knowledge. :param dir: the step dir to example :return: a set of possible states for the step """ # If the directory doesn't exist, the step is incomplete or uncacheable. if not dir.exists(): return {StepState.INCOMPLETE, StepState.UNCACHEABLE} # If the lock file exists and is locked, the step is running. lock_file = dir / "lock" if lock_file.exists(): lock = FileLock(lock_file) try: lock.acquire(0.1) lock.release() except TimeoutError: return {StepState.RUNNING} # If the directory is empty except for the work dir and the lock file, the step is running, incomplete, # or failed. But it can't be running because then the lockfile would be locked, so it can only be # incomplete or failed. for dir_entry in dir.iterdir(): if dir_entry.name == "work" and dir_entry.is_dir(): continue if dir_entry.name == "lock" and dir_entry.is_file(): continue break else: return {StepState.INCOMPLETE, StepState.FAILED} return set(StepState) @staticmethod def _fix_step_info(step_info: StepInfo) -> None: """ Tragically we need to run a fix-up step over StepInfo objects that are freshly read from the database. This is for backwards compatibility. This function operates on the `step_info` object in place. """ if isinstance(step_info.error, BaseException): step_info.error = exception_to_string(step_info.error) def step_info(self, step_or_unique_id: Union[Step, str]) -> StepInfo: with SqliteDict(self.step_info_file) as d: def find_or_add_step_info(step_or_unique_id: Union[Step, str]) -> StepInfo: if isinstance(step_or_unique_id, Step): unique_id = step_or_unique_id.unique_id else: unique_id = step_or_unique_id try: step_info = d[unique_id] except KeyError: if not isinstance(step_or_unique_id, Step): raise step = step_or_unique_id for dep in step.dependencies: find_or_add_step_info(dep) step_info = StepInfo.new_from_step(step) d[unique_id] = step_info del step # Perform some sanity checks. Sqlite and the file system can get out of sync # when a process dies suddenly. step_dir = self.step_dir(unique_id) step_state_guesses = self.guess_step_dir_state(step_dir) or step_info.state if step_info.state not in step_state_guesses: if step_info.state == StepState.RUNNING: # We think the step is running, but it can't possibly be running, so we go ahead and # assume the step is incomplete. step_info.start_time = None step_info.end_time = None d[unique_id] = step_info else: possible_states = ", ".join(s.value for s in step_state_guesses) raise IOError( f"The step '{unique_id}' is marked as being {step_info.state.value}, but we " f"determined it can only be one of {{{possible_states}}}. If you are positive " f"this is a screw-up, delete the directory at '{step_dir}' and try again." ) return step_info result = find_or_add_step_info(step_or_unique_id) d.commit() self._fix_step_info(result) return result def _step_lock_file(self, step_or_unique_id: Union[Step, str]) -> Path: step_dir = self.step_dir(step_or_unique_id) step_dir.mkdir(parents=True, exist_ok=True) return step_dir / "lock" def step_starting(self, step: Step) -> None: # We don't do anything with uncacheable steps. if not step.cache_results: return # Gather the existing step info first. Step info automatically fixes itself if steps are # marked as "running" but are not locked. This happens, for example, when a process # gets killed. To make sure this works, we have to get the step info before we start # messing with locks. step_info = self.step_info(step) if step_info.state not in {StepState.INCOMPLETE, StepState.FAILED}: raise StepStateError( step, step_info.state, context="If you are certain the step is not running somewhere else, delete the lock " f"file at {self._step_lock_file(step)}.", ) if step_info.state == StepState.FAILED: # Refresh environment metadata since it might be out-of-date now. step_info.refresh() lock = FileLock(self._step_lock_file(step), read_only_ok=True) lock.acquire_with_updates(desc=f"acquiring lock for '{step.name}'") self.locks[step] = lock try: step_info.start_time = utc_now_datetime() step_info.end_time = None step_info.error = None step_info.result_location = None with SqliteDict(self.step_info_file) as d: d[step.unique_id] = step_info d.commit() except: # noqa: E722 lock.release() del self.locks[step] raise def step_finished(self, step: Step, result: T) -> T: # We don't do anything with uncacheable steps. if not step.cache_results: return result lock = self.locks[step] step_info = self.step_info(step) if step_info.state != StepState.RUNNING: raise StepStateError(step, step_info.state) self.step_cache[step] = result if hasattr(result, "__next__"): assert isinstance(result, Iterator) # Caching the iterator will consume it, so we write it to the cache and then read from the cache # for the return value. result = self.step_cache[step] # Mark the step as finished step_info.end_time = utc_now_datetime() step_info.result_location = str(self.step_dir(step).absolute()) with SqliteDict(self.step_info_file) as d: d[step.unique_id] = step_info d.commit() lock.release() del self.locks[step] return result def step_failed(self, step: Step, e: BaseException) -> None: # We don't do anything with uncacheable steps. if not step.cache_results: return lock = self.locks[step] try: step_info = self.step_info(step) if step_info.state != StepState.RUNNING: raise StepStateError(step, step_info.state) step_info.end_time = utc_now_datetime() step_info.error = exception_to_string(e) with SqliteDict(self.step_info_file) as d: d[step.unique_id] = step_info d.commit() finally: lock.release() del self.locks[step] def register_run(self, targets: Iterable[Step], name: Optional[str] = None) -> Run: # sanity check targets targets = list(targets) if name is None: while name is None or (self.runs_dir / name).exists(): name = petname.generate() run_dir = self.runs_dir / name # clean any existing run directory if run_dir.exists(): for filename in run_dir.iterdir(): filename.unlink() else: run_dir.mkdir(parents=True, exist_ok=True) # write step info for all steps all_steps = set(targets) for step in targets: all_steps |= step.recursive_dependencies self._save_registered_run(name, all_steps) # write targets for target in targets: if target.cache_results: target_path = self.step_dir(target) (run_dir / target.name).symlink_to(os.path.relpath(target_path, run_dir)) self.latest_dir.unlink(missing_ok=True) self.latest_dir.symlink_to(run_dir) return self.registered_run(name) def registered_runs(self) -> Dict[str, Run]: return { str(run_dir.name): self.registered_run(run_dir.name) for run_dir in self.runs_dir.iterdir() if run_dir.is_dir() } def registered_run(self, name: str) -> Run: run_dir = self.runs_dir / name if not run_dir.is_dir(): raise KeyError(name) steps_for_run = self._load_registered_run(name) return Run(name, steps_for_run, datetime.fromtimestamp(run_dir.stat().st_ctime)) def _run_step_info_file(self, name: str) -> Path: return self.runs_dir / name / "stepinfo.json" def _save_registered_run(self, name: str, all_steps: Iterable[Step]) -> None: step_unique_ids = {} with SqliteDict(self.step_info_file) as d: for step in all_steps: try: step_info = d[step.unique_id] step_info.name = step.name d[step.unique_id] = step_info except KeyError: d[step.unique_id] = StepInfo.new_from_step(step) step_unique_ids[step.name] = step.unique_id d.commit() run_step_info_file = self._run_step_info_file(name) with open(run_step_info_file, "w") as file_ref: json.dump(step_unique_ids, file_ref) def _load_registered_run(self, name: str) -> Dict[str, StepInfo]: run_step_info_file = self._run_step_info_file(name) try: with open(run_step_info_file, "r") as file_ref: step_ids = json.load(file_ref) except FileNotFoundError: # for backwards compatibility run_dir = self.runs_dir / name step_ids = {} for step_symlink in run_dir.iterdir(): if not step_symlink.is_symlink(): continue step_name = str(step_symlink.name) unique_id = str(step_symlink.resolve().name) step_ids[step_name] = unique_id with SqliteDict(self.step_info_file, flag="r") as d: steps_for_run = {} for step_name, unique_id in step_ids.items(): step_info = d[unique_id] assert isinstance(step_info, StepInfo) self._fix_step_info(step_info) steps_for_run[step_name] = step_info return steps_for_run def run_dir(self, name: str) -> Path: """ Returns the directory where a given run is stored. :param name: The name of the run :return: The directory where the results of the run are stored If the run does not exist, this returns the directory where it will be stored if you call :meth:`register_run()` with that name. """ return self.runs_dir / name def capture_logs_for_run(self, name: str): return file_handler(self.run_dir(name) / "out.log")
|
__label__pos
| 0.999682 |
my photos upside down??
Discussion in 'iPad Help' started by triathlon, May 17, 2011.
1. triathlon
Offline
triathlon iPF Noob
Joined:
May 17, 2011
Messages:
2
Thanks Received:
0
Trophy Points:
0
Ratings:
+0 / 0
Hi First time i've used this forum - help please.
New to mac and just purchased ipad 2 . When i email a photo it appears upside down. Tried to save to my PC ( Windows 7 - Microsoft 2010 applications) and still upside down. Help please.
Thank you
2. peled
Offline
peled iPad Junkie
Joined:
Oct 31, 2010
Messages:
890
Thanks Received:
3
Trophy Points:
0
Location:
Israel
Ratings:
+3 / 0
It is a known issue.
This are the General rules. BUT it can be reversed regarding the mean being used to transmit the photo and/or the target getting the photo.
taking a picture with the "Home" button facing right it will make your pictures look upside down.
taking a picture with the "Home" button facing left it will make your pictures look "Correct".
taking a picture with the "Home" button on the bottom will make your pictures look pointed to the Side.
when you download them or email them, however, if the "Home" button is facing right, they are right side up....
3. triathlon
Offline
triathlon iPF Noob
Joined:
May 17, 2011
Messages:
2
Thanks Received:
0
Trophy Points:
0
Ratings:
+0 / 0
Thank you. I have already taken the photos and they cannot be repeated, desperate to get them onto my computer as they are "family" photos and need to work with them. Is there anything i can do with the photos i have taken to save them the right way up on the microsft PC. Is there any app?
4. ziggs
Offline
ziggs iPF Novice
Joined:
Feb 6, 2011
Messages:
13
Thanks Received:
0
Trophy Points:
0
Location:
california
Ratings:
+0 / 0
Thanks for these suggestions, but for me, no matter which way the home button is facing when I take OR email the photo, it always appears upside down when received. I've tried all combinations I can think of. Any new answers out there?
5. f4780y
Offline
f4780y Super Moderator Staff Member
Joined:
Sep 11, 2010
Messages:
7,109
Thanks Received:
635
Trophy Points:
113
Location:
Troon, Scotland
Ratings:
+635 / 0
You can rotate them quite easily on Windows. Just find them in explorer, right click on them, and choose rotate clockwise twice... :)
6. Waki
Offline
Waki iPF Noob
Joined:
Aug 22, 2011
Messages:
3
Thanks Received:
0
Trophy Points:
0
Location:
Ontario canada
Ratings:
+0 / 0
Upside down
People just don't seem to understand. The pictures are being forwarded normally and arrive upside down. Just started. Can't anyone help . Steve ???
7. Gaybinator2
Offline
Gaybinator2 iPF Noob
Joined:
Dec 1, 2012
Messages:
5
Thanks Received:
0
Trophy Points:
0
Ratings:
+0 / 0
Brand new to iPad. I have problem of emailed photos arriving upside down. They appear normal in the gallery of photos. Besides bugging my friends, I sometimes send photos to folks that will only give me one second of their time - if it's not right - it sucks to be me.
Also, I've tried using the USB to hook to my Windows PC and it doesn't recognize it. Read elsewhere on this forum to rotate photos in Windows. How does one get the photos on the PC? Doesn't seem very practical - why have an iPad?
8. PeterJMelb
Offline
PeterJMelb iPad Fan
Joined:
Sep 30, 2012
Messages:
238
Thanks Received:
19
Trophy Points:
18
Location:
Australia
Ratings:
+20 / 0
Hi Gab.
Just to help with your USB to PC.
After you connect open Windows Explorer.
Then computer.
Then you should see "your name" iPad.
Then Internal storage.
Then DCIM.
Then open one or more folders.
You should then see any photos or videos that are in your Camera Roll.
9. Gaybinator2
Offline
Gaybinator2 iPF Noob
Joined:
Dec 1, 2012
Messages:
5
Thanks Received:
0
Trophy Points:
0
Ratings:
+0 / 0
It works! Thank you.
10. PeterJMelb
Offline
PeterJMelb iPad Fan
Joined:
Sep 30, 2012
Messages:
238
Thanks Received:
19
Trophy Points:
18
Location:
Australia
Ratings:
+20 / 0
Hi Gab.
A pleasure to help.
Re your photo received upside down.
I have had that some time ago.
So I just sent a photo to myself using a photo in Camera Roll.
It received the right way.
So give it another try.
11. Gaybinator2
Offline
Gaybinator2 iPF Noob
Joined:
Dec 1, 2012
Messages:
5
Thanks Received:
0
Trophy Points:
0
Ratings:
+0 / 0
Don't know how to respond, except with quote. I think the problem may have been that I was sending directly from the camera roll, instead of inserting directly in the email.
Share This Page
Search tags for this page
downloading photos from ipad to website but they are upside down
,
how come picture are upside down when uploaded off an i pad
,
how do i turn a picture right side up that was sent to me from an ipad to an reg
,
how do you show a picture upright on the bottom of an ee pad
,
ipad loading photos upside down
,
ipad photos arrive upside down in windows
,
ipad photos upside down
,
ipad pictures upside down
,
ipad selfy image upside down
,
ipad takes picture upside down
,
my pictures get delivered upside down on my ipad
,
my pictures on kijiji are upside down
,
pictures import upside down ipad windows 7
,
took pic on i pad upside down how to make it right on computer
,
upload pictures from i-pad to computer are upside down
,
why are photos showing upside down when taken with ipad
,
why do my photos upload upside down from my ipad
,
why do my pictures come upside down from ipad to computer
,
why do my pictures taken on my ipad look huge and upsidedown when i email them
,
why ipad photos import upside down
|
__label__pos
| 0.554151 |
About the SQL Server Foreign Key Clause
By: Dusan Petkovic
A foreign key is a column or group of columns in one table that contains values that match the primary key values in the same or another table. Each foreign key is defined using the FOREIGN KEY clause combined with the REFERENCES clause.
The FOREIGN KEY clause has the following form:
0144_003
The FOREIGN KEY clause defines all columns explicitly that belong to the foreign key. The REFERENCES clause specifies the table name with all columns that build the corresponding primary key. The number and the data types of the columns in the FOREIGN KEY clause must match the number and the corresponding data types of columns in the REFERENCES clause (and, of course, both of these must match the number and data types of the columns in the primary key of the referenced table).
The table that contains the foreign key is called the referencing table, and the table that contains the corresponding primary key is called the parent table or referenced table. Example 1 shows the specification of the foreign key in the works_on table of the sample database.
NOTE
You have to drop theworks_ontable before you execute the following example.
EXAMPLE 1
0145_001
The works_on table in Example 1 is specified with two declarative integrity constraints: prim_works and foreign_works. Both constraints are table-level constraints, where the former specifies the primary key and the latter the foreign key of the works_on table. Further, the constraint foreign_works specifies the employee table as the parent table and its emp_no column as the corresponding primary key of the column with the same name in the works_on table.
The FOREIGN KEY clause can be omitted if the foreign key is defined as a column-level constraint, because the column being constrained is the implicit column “list” of the foreign key, and the keyword REFERENCES is sufficient to indicate what kind of constraint this is. The maximum number of FOREIGN KEY constraints in a table is 63.
A definition of the foreign keys in tables of a database imposes the specification of another important integrity constraint: the referential integrity.
Leave a Reply
|
__label__pos
| 0.992458 |
Amazon CloudWatch Events
User Guide
Tutorial: Schedule Automated Amazon EBS Snapshots Using CloudWatch Events
You can run CloudWatch Events rules according to a schedule. In this tutorial, you create an automated snapshot of an existing Amazon Elastic Block Store (Amazon EBS) volume on a schedule. You can choose a fixed rate to create a snapshot every few minutes or use a cron expression to specify that the snapshot is made at a specific time of day.
Important
Creating rules with built-in targets is supported only in the AWS Management Console.
Step 1: Create a Rule
Create a rule that takes snapshots on a schedule. You can use a rate expression or a cron expression to specify the schedule. For more information, see Schedule Expressions for Rules.
To create a rule
1. Open the CloudWatch console at https://console.aws.amazon.com/cloudwatch/.
2. In the navigation pane, choose Events, Create rule.
3. For Event Source, do the following:
1. Choose Schedule.
2. Choose Fixed rate of and specify the schedule interval (for example, 5 minutes). Alternatively, choose Cron expression and specify a cron expression (for example, every 15 minutes Monday through Friday, starting at the current time).
4. For Targets, choose Add target and then select EC2 CreateSnapshot API call. You may have to scroll up in the list of possible targets to find EC2 CreateSnapshot API call.
5. For Volume ID, type the volume ID of the targeted Amazon EBS volume.
6. Choose Create a new role for this specific resource. The new role grants the target permissions to access resources on your behalf.
7. Choose Configure details.
8. For Rule definition, type a name and description for the rule.
9. Choose Create rule.
Step 2: Test the Rule
You can verify your rule by viewing your first snapshot after it is taken.
To test your rule
1. Open the Amazon EC2 console at https://console.aws.amazon.com/ec2/.
2. In the navigation pane, choose Elastic Block Store, Snapshots.
3. Verify that the first snapshot appears in the list.
4. (Optional) When you are finished, you can disable the rule to prevent additional snapshots from being taken.
1. Open the CloudWatch console at https://console.aws.amazon.com/cloudwatch/.
2. In the navigation pane, choose Events, Rules.
3. Select the rule and choose Actions, Disable.
4. When prompted for confirmation, choose Disable.
|
__label__pos
| 0.98536 |
스웨덴 대중교통정보(Västtrafik)
The vasttrafik sensor will provide you traveling details for the larger Göteborg area in Sweden from the Västtrafik public transportation service.
You must create an application here to obtain a key and a secret.
Add the data to your configuration.yaml file as shown in the example:
# Example configuration.yaml entry
sensor:
- platform: vasttrafik
key: YOUR_API_KEY
secret: YOUR_API_SECRET
departures:
- from: Musikvägen
Configuration Variables
key
(string)(Required)
The API key to access your Västtrafik account.
secret
(string)(Required)
The API secret to access your Västtrafik account.
departures
(list)(Required)
List of travel routes.
name
(string)(Optional)
Name of the route.
from
(string)(Required)
The start station.
heading
(string)(Optional)
Direction of the traveling.
lines
(list | string)(Optional)
Only consider these lines.
delay
(string)(Optional)
Delay in minutes.
Default value:
0
The data are coming from Västtrafik.
A full configuration example could look like this:
# Example configuration.yaml entry
sensor:
- platform: vasttrafik
key: YOUR_API_KEY
secret: YOUR_API_SECRET
departures:
- name: Mot järntorget
from: Musikvägen
heading: Järntorget
lines:
- 7
- GRÖN
delay: 10
|
__label__pos
| 0.711846 |
Test-Driven JavaScript Development with JsUnit
The last time I used JsUnit was when I first joined Talis. At the time my colleague Ian Davis asked me to write a JavaScript client library for one of our platform API’s to make it easy for developers to perform bibliographic searches. It wasn’t a particularly difficult task and I did it relatively easily. It was around the same time that Rob was extolling the virtues of Test Driven Development to me, and to try to prove his point we agreed to do an experiment: he asked me to set aside the library I had written and to see if I could develop the library again using test driven development. It meant I had to figure out how to unit test JavaScript, and thats when I found JsUnit. I did the exercise again and even I was impressed with the results. By having to think about the tests first, and design the interface to the library as I wrote each test it evolved very differently to my original solution. Consequently it was also far superior.
Anyway fast forward two and half years and I find myself in a similar situation. We have only just begun to start writing bits of JavaScript code based around prototype.js to help us create richer user experiences in our products if we detect that JavaScript is enabled in the browser. This now means I want to ensure that we are using the same rigour when writing these bits of code as we do in all other parts of the application – just because its JavaScript and executed inside the browser this doesn’t mean it shouldn’t be tested.
I’ve just spent the morning getting JsUnit installed and figuring out how to get it to run as part of a continuous integration process, as well as thinking about how to write tests for some slightly different scenarios. Here’s what I’ve discovered today:
Installing JsUnit
Couldn’t be easier … go to www.jsunit.net and download the latest distribution, and extract into a folder on your system somewhere, lets say
/jsunit for now. The distribution contains both the standard test runner as well as jsunit server which you will need it if you want to hook it into an ant build.
Writing Tests
In JsUnit we place our tests in a HTML Test Page which is the equivalent of a Test Class, this test page must have a script reference to the jsUnitCore.js so the test runner knows its a test. So lets work through a simple example. Let’s say we want to write a function that returns the result of adding two parameters together. The Test Page for this might look like this:
1.
2. <html>
3. <head>
4. <title>Test Page for add(value1, value2)</title>
5. <script language="javascript" src="/jsunit/app/jsUnitCore.js"></script>
6. <script language="javascript" src="scripts/addValues.js"></script>
7. </head>
8. <body>
9. <script language="javascript">
10. function testAddWithTwoValidArguments() {
11. assertEquals("2 add 3 is 5", 5, add(2,3) );
12. }
13. </script>
14. </body>
15. </html>
16.
For now lets save this file to /my-jsunit-tests/addTest.html
To run the test you need to point your browser at the following local url:
file:///jsunit/testRunner.html?testPage=/my-jsunit-tests/addTest.html
The test will not run since we haven’t defined the add function. Let’s do that (very crudely):
1.
Now if you go to that URL it will run the test and report that it passed. Excellent, we’ve written a simple test in JavaScript. Now lets extend this a little, lets say I want to write something more complicated like a piece of JavaScript that uses Prototype.js to update the DOM of a page. Is this possible? Can I do that test first? It turns out that you can …
Lets say we have a div on the page called ‘tableOfContents’ and we want to use Prototype.js to dynamically inject a link onto the page that says [show] and lets say we want to write a function that will toggle this link to say [hide] when the user clicks on it, this link will also set the visible state of the table of contents itself which for now we’ll say is just an ordered list (OL). Our test page is going to be slightly more complex …
1.
2. <html>
3. <head>
4. <title>Test Page for multiplyAndAddFive(value1, value2)</title>
5. <script language="javascript" src="/jsunit/app/jsUnitCore.js"></script>
6. <script language="javascript" src="scripts/prototype/prototype-1.6.0.2.js"></script>
7. <script language="javascript" src="scripts/tableOfContents.js"></script>
8. </head>
9. <body>
10. <div id="tableOfContents">
11. <h2 id="tableOfContentsHeader">Table of contents</h2>
12. <ol id="list-toc">
13. </ol>
14. </div>
15. <script language="javascript">
16. function testTOC()
17. {
18. var title = $(‘lnkToggleTOC’).title;
19. assertEquals("should be Show the table of contents", "Show the table of contents", title);
20.
21. toggleTableOfContents();
22.
23. var title = $(‘lnkToggleTOC’).title;
24. assertEquals("should be Hide the table of contents", "Hide the table of contents", title);
25.
26. }
27. </script>
28. </body>
29. </html>
30.
There are some differences in this test. Firstly the html contains some markup, that I’m using as the containers for my table of contents. The table of contents has a header and the contents in the form of an empty ordered list. Now I know that I want the javascript to execute when the page is loaded, so I’ve written this test to assume that the script will run and will inject and element called ‘linkToggleToc’ which is the show/hide link next to the heading. Therefore the first line of the test uses prototype.js element selector notation to set a local variable called title to the value of the title of the element that has the id ‘linkToggleToc’. If the script failes to execute then this element will not be present and the subsequent assert will fail. If the assert succeeds, then we call the toggleTableOfContents function and then repeat the same evaluation only now we are checking to see if the link has been changed.
The code for tableOfContents.js is as follows:
1. span class=”st0″>’load’‘Show the table of contents’‘Hide the table of contents’‘list-toc’).hide();
2. $(‘tableOfContentsHeader’‘inline’‘a’, { ‘id’: ‘lnkToggleTOC’, ‘href’: ‘javascript:toggleTableOfContents()’, ‘title’: titleShowTOC, ‘class’: ‘ctr’ }).update("[show]");
3.
4. $(‘tableOfContentsHeader’‘after’‘list-toc’‘lnkToggleTOC’).update(‘[show]’);
5. $(‘lnkToggleTOC’‘lnkToggleTOC’).update(‘[hide]’);
6. $(‘lnkToggleTOC’).title = titleHideTOC;
7. }
8. }
Now if we run this test in the same way we executed the previous test it will pass. I accept that this example is a bit contrived since I know it already works and I’ve skimmed over some of the details around it. The point I’m trying to make though is that you can write unit tests for pretty much any kind of JavaScript you need to write, even tests for scripts that do dom manipulation, or make AjaxRequests etc.
Setting up the JsUnit server so you can run it in a build
JsUnit ships with its own ant build file that requires some additional configuration before you can run the server. The top of the build file contains a number of properties that need to be set, here’s what you set them to ( using the paths that I’ve been using in the above example)
1.
2. <project name="JsUnit" default="create_distribution" basedir=".">
3.
4. <property
5. name="browserFileNames"
6. value="/usr/bin/firefox-2" />
7.
8. <property
9. id="closeBrowsersAfterTestRuns"
10. name="closeBrowsersAfterTestRuns"
11. value="false" />
12.
13. <property
14. id="ignoreUnresponsiveRemoteMachines"
15. name="ignoreUnresponsiveRemoteMachines"
16. value="true" />
17.
18. <property
19. id="logsDirectory"
20. name="logsDirectory"
21. value="/my-jsunit-tests/results/" />
22.
23. <property
24. id="port"
25. name="port"
26. value="9001" />
27.
28. <property
29. id="remoteMachineURLs"
30. name="remoteMachineURLs"
31. value="" />
32.
33. <property
34. id="timeoutSeconds"
35. name="timeoutSeconds"
36. value="60" />
37.
38. <property
39. id="url"
40. name="url"
41. value="file:///jsunit/testRunner.html?testPage=/my-jsunit-tests/tocTest.html" />
42. </project>
43.
You can then type the following command in the root of the jsunit distribution to launch the jsunit server, executes the test, and outputs a test results log file, formatted just like JUnit, and reports that the build was either successful or not if the test fails.
ant standalone_test
Remember that in this example I’ve used a simple Test Page, however JsUnit, like any XUnit framework allows you to specify Test Suites, which is how you would run multiple Test Pages. Also the parameters in the build file woudn’t be hardcoded in you continuous integration process but would rather be passed in, and you would want to call it from your projects main ant build file … all of which is pretty simple to configure, once you know what is you want to do and what’s possible.
|
__label__pos
| 0.91334 |
Category:
What is a Markup Language?
Article Details
• Written By: Erin J. Hill
• Edited By: Bronwyn Harris
• Last Modified Date: 11 June 2018
• Copyright Protected:
2003-2018
Conjecture Corporation
• Print this Article
Free Widgets for your Site/Blog
In the 1870s and 1880s, fans ridiculed baseball players who wore gloves for catching and fielding as “unmanly.” more...
June 19 , 1910 : The first Father's Day celebration occurred. more...
A markup language is a combination of words and symbols which give instructions on how a document should appear. For example, a tag may indicate that words are written in italics or bold type. Although the most common and most widely used markup languages are written for computers, the concept of a markup language is not limited to computer programming.
One of the oldest, and at one time the most commonly used, markup languages is that which is used by editors to instruct writers on how something should be written or how it should appear in the final draft of a piece. When done in longhand, the editor generally uses symbols and written instructions in an ink color different from that of the author; usually blue or red. This practice has been replaced in many areas thanks to the widespread use of computers, but teachers and sometimes journalists are still required to know proper editing markup.
Ad
The most widely known markup language today is likely hypertext markup language (HTML). This is the language used by web browsers to display websites. Coding can be typed by hand and uploaded through a word processor, or created in one of many web design programs. There are new variations of this language which have updated codes and rules. Dynamic hypertext markup language is an example. Multiple codes can be strung together and can be used to create a style sheet to ensure that a website has a unified appearance.
Many word processors also use some type of markup language to change the appearance of text within the document. This is generally not seen by users of the program, but takes place behind the scenes. These types of languages are created by computer programmers and are typically used only by the computer.
The main things most markup languages have in common is that they dictate the appearance of text or full pages and they are not usually seen by the end user in the finished product. In HTML, only the web browser reads and deciphers the meanings of certain codes. For instance, the <b> tag instructs a browser to display all text that comes after it in bold text. To end the bold text, the following tag is inserted: </b>. Although many people will never use a markup language themselves, they will likely use a product or read a web page that implements their use.
Ad
You might also Like
Recommended
Discuss this Article
burcinc
Post 3
@alisha-- I'm not an expert but I do some markup language for my personal site. As far as I know, all of those are universal languages for markup. SGML stands for "Standard Generalized Markup Language," HyTime is something like "Hypermedia Time Language" and DSSSL is "Document Style Semantics and Specification Language."
I think all of these came out because there were too many markup languages and one markup language could only be used for one program and not for others. It became necessary to have a universal language for markup that could be used for most if not all computer programs. But as you can see there are now multiple "universal" markup programs which really defies the whole purpose of having a universal language I think.
discographer
Post 2
Hi, I have been trying to learn about markup language. I keep running into several different acronyms when I'm reading about it like SGML, HyTime and DSSSL. What do these mean and what do they have to do with markup language?
serenesurface
Post 1
I remember when HTML markup language was foreign to most other than website programmers. But today I see "how-to" pages all over the net teaching people to use markup languages. I think these social networking sites have made markup language more popular because everyone would want their site to be different and unique than others'.
I think especially famous and popular individuals are using social networking sites to both interact with their fans and to advertise their works. I'm sure most actually hire someone to do this stuff. But I know some people also have interest in computers and website building, so they try to learn some markup language to customize their sites themselves.
I would love to
this if I could. I think it's always better to do it yourself because you know exactly what you want. Unfortunately, I have absolutely no talent in this field. I wonder if there is software out there that can make markup language easier to use for people like me? That would be excellent.
Post your comments
Post Anonymously
Login
username
password
forgot password?
Register
username
password
confirm
email
|
__label__pos
| 0.833902 |
slinky773 slinky773 - 9 months ago 68
Python Question
Non Brute Force Solution to Project Euler 25
Project Euler Problem 25:
The Fibonacci sequence is defined by the recurrence relation:
Fn = Fn−1 + Fn−2, where F1 = 1 and F2 = 1. Hence the first 12 terms
will be F1 = 1, F2 = 1, F3 = 2, F4 = 3, F5 = 5, F6 = 8, F7 = 13, F8 =
21, F9 = 34, F10 = 55, F11 = 89, F12 = 144
The 12th term, F12, is the first term to contain three digits.
What is the first term in the Fibonacci sequence to contain 1000
digits?
I made a brute force solution in Python, but it takes absolutely forever to calculate the actual solution. Can anyone suggest a non brute force solution?
def Fibonacci(NthTerm):
if NthTerm == 1 or NthTerm == 2:
return 1 # Challenge defines 1st and 2nd term as == 1
else:
return Fibonacci(NthTerm-1) + Fibonacci(NthTerm-2) # recursive definition of Fib term
FirstTerm = 0 # For scope to include Term in scope of print on line 13
for Term in range(1, 1000): # Arbitrary range
FibValue = str(Fibonacci(Term)) # Convert integer to string for len()
if len(FibValue) == 1000:
FirstTerm = Term
break # Stop there
else: continue # Go to next number
print "The first term in the\nFibonacci sequence to\ncontain 1000 digits\nis the", FirstTerm, "term."
Answer
You can write a fibonacci function that runs in linear time and with constant memory footprint, you don't need a list to keep them. Here's a recursive version (however, if n is big enough, it will just stackoverflow)
def fib(a, b, n):
if n == 1:
return a
else:
return fib(a+b, a, n-1)
print fib(1, 0, 10) # prints 55
Here's a version that won't ever stackoverflow
def fib(n):
a = 1
b = 0
while n > 1:
a, b = a+b, a
n = n - 1
return a
print fib(100000)
And that's fast enough:
$ time python fibo.py
3364476487643178326662161200510754331030214846068006390656476...
real 0m0.869s
But calling fib until you get a result big enough isn't perfect: the first numbers of the serie are calculated multiple times. You can calculate the next fibonacci number and check its size in the same loop:
a = 1
b = 0
n = 1
while len(str(a)) != 1000:
a, b = a+b, a
n = n + 1
print "%d has 1000 digits, n = %d" % (a, n)
|
__label__pos
| 0.999603 |
US7840397B2 - Simulation method - Google Patents
Simulation method Download PDF
Info
Publication number
US7840397B2
US7840397B2 US11633657 US63365706A US7840397B2 US 7840397 B2 US7840397 B2 US 7840397B2 US 11633657 US11633657 US 11633657 US 63365706 A US63365706 A US 63365706A US 7840397 B2 US7840397 B2 US 7840397B2
Authority
US
Grant status
Grant
Patent type
Prior art keywords
functional
model
component
method
behavior
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active, expires
Application number
US11633657
Other versions
US20070150248A1 (en )
Inventor
Derek Chiou
Original Assignee
Derek Chiou
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Grant date
Links
Images
Classifications
• GPHYSICS
• G06COMPUTING; CALCULATING; COUNTING
• G06FELECTRIC DIGITAL DATA PROCESSING
• G06F17/00Digital computing or data processing equipment or methods, specially adapted for specific functions
• G06F17/50Computer-aided design
• G06F17/5009Computer-aided design using simulation
• G06F17/5022Logic simulation, e.g. for logic circuit operation
• GPHYSICS
• G06COMPUTING; CALCULATING; COUNTING
• G06FELECTRIC DIGITAL DATA PROCESSING
• G06F17/00Digital computing or data processing equipment or methods, specially adapted for specific functions
• G06F17/50Computer-aided design
• G06F17/5009Computer-aided design using simulation
• G06F17/5036Computer-aided design using simulation for analog modelling, e.g. for circuits, spice programme, direct methods, relaxation methods
• GPHYSICS
• G06COMPUTING; CALCULATING; COUNTING
• G06FELECTRIC DIGITAL DATA PROCESSING
• G06F2217/00Indexing scheme relating to computer aided design [CAD]
• G06F2217/68Processors
• GPHYSICS
• G06COMPUTING; CALCULATING; COUNTING
• G06FELECTRIC DIGITAL DATA PROCESSING
• G06F9/00Arrangements for program control, e.g. control units
• G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
• G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
• GPHYSICS
• G06COMPUTING; CALCULATING; COUNTING
• G06FELECTRIC DIGITAL DATA PROCESSING
• G06F9/00Arrangements for program control, e.g. control units
• G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
• G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
• G06F9/30098Register arrangements
• G06F9/3012Organisation of register space, e.g. banked or distributed register file
• G06F9/30134Register stacks; shift registers
• GPHYSICS
• G06COMPUTING; CALCULATING; COUNTING
• G06FELECTRIC DIGITAL DATA PROCESSING
• G06F9/00Arrangements for program control, e.g. control units
• G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
• G06F9/30Arrangements for executing machine instructions, e.g. instruction decode
• G06F9/38Concurrent instruction execution, e.g. pipeline, look ahead
• G06F9/3877Concurrent instruction execution, e.g. pipeline, look ahead using a slave processor, e.g. coprocessor
• GPHYSICS
• G06COMPUTING; CALCULATING; COUNTING
• G06FELECTRIC DIGITAL DATA PROCESSING
• G06F9/00Arrangements for program control, e.g. control units
• G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
• G06F9/44Arrangements for executing specific programs
• G06F9/448Execution paradigms, e.g. implementations of programming paradigms
• G06F9/4494Execution paradigms, e.g. implementations of programming paradigms data driven
Abstract
A simulator is partitioned into a functional component and a behavior prediction component and the components are executed in parallel. The execution path of the functional component is used to drive the behavior prediction component and the behavior prediction component changes the execution path of the functional component.
Description
RELATED APPLICATION
This application claims the benefit of U.S. Provisional Application No. 60/741,587, filed on Dec. 2, 2005. The entire teachings of the above application are incorporated herein by reference.
BACKGROUND OF THE INVENTION
Simulation is one method to predict the behavior of a target system (we use the term “target” to mean the system that is being simulated). A simulator mimics some or all of the behavior of the target. Simulation is often used when measuring the target system itself is undesirable for a variety of reasons including target unavailability, target cost, or the inability to appropriately measure the target.
Simulators are used in almost all fields and are implemented using a variety of technologies. Two examples of other simulators include wind tunnels used to measure the coefficient of drag on miniature models of automobiles and war games using live participants to test the capabilities of soldiers, commanders and military machinery. There is even a class of simulator games such as Simcity that simulates the growth and health of a city under the guidance of a player who acts as the city planner.
Though simulators can be implemented in a variety of ways, many current simulator hosts are computers (we use the term “host” to mean the system that runs the simulator.) A computer simulation is reproducible, duplicate-able so that many copies can be run, does not require physical objects and are generally easy to observe.
In addition to commonly serving as simulation hosts, computers are also simulation targets. Computers have long been sufficiently complex to require simulation to model behavior with any precision. Predicting the behavior of a computer system is useful for a variety of purposes including but not limited to (i) evaluating architectural alternatives, (ii) verifying a design, and (iii) development, debugging and tuning of compilers, operating systems and applications. A variety of behaviors ranging from performance to power to reliability is all useful to predict.
Virtually all computer simulators (we use the term “computer simulators” to mean “simulators of computer systems”) run on computer hosts. One significant issue facing computer simulators is simulation speed, an important concern for all simulators. For example, a weather simulator that runs slower than real time has limited efficacy. One may argue, however, that as successive generations of computers get faster over time, the simulators that run on those computers will also get faster. In fact, simulators of the physical world do run faster as the host computer increases in speed because the physical world does not increase in complexity over time.
Simulators of computers, however, do not. The problem is rooted in the fact that the more complex the simulated target becomes, the more activity it engages in per unit simulated time. This results in an increase in the computation per simulated unit time that must be performed by the host. The greater the computation per simulated unit time, the slower the simulator. Unlike the physical world, computer targets grow in complexity as fast as or faster than the computer hosts improve in performance. Thus, the increased speed of the host is consumed by the increased complexity of the target, resulting in computer simulation speeds remaining roughly constant over time.
Computers are complex systems consisting of one or more components that run concurrently and interact with each other. These components include processors, memory, disk, video, network interfaces, and so on. Each component itself is a complex system, making it very difficult to predict almost all aspects of their behavior including performance, power consumption and even functional correctness. Thus, in order to accurately simulate their behavior, we need to faithfully model the interactions between each component and the components it interacts with. On such component in a computer system is a processor which are essentially special-purpose hardware designed to execute programs expressed in a specific instruction set architecture (ISA). An ISA is a specification that includes a set of instructions, such as ADD, BRANCH and LOAD/STORE, as well as some model of the storage of the processor such as a register specification and a memory specification. All processors implement some ISA allowing programs that assume that ISA is to be executed by that processor.
Different processor families have different ISAs. For example, one of the most common ISAs is the Intel IA-32, which is often called x86. Processors made by companies such as Intel, AMD, Centaur/VIA, and Transmeta implement the IA-32 instruction set. Different ISAs are not only possible but, at one time, they proliferated. The Sun Sparc ISA, Motorola/IBM PowerPC ISA, the DEC/Compaq/HP Alpha ISA, the IBM 360 ISA and the MIPS ISA are all ISAs that were supported by real processors.
ISAs tend to evolve over time. The original x86 instruction set, for example, did not include floating point instructions. As the need for floating point became clear and reasonable to implement, however, floating point instructions were added. Many other instructions were added to the x86 instruction set, including MMX and SISD instructions.
Though all processors implement an ISA, different processors implementing the same ISA may have very different organizations. The underlying organization of a processor is called that processor's micro-architecture. The micro-architecture consists of hardware and potentially software components that implement the ISA including instructions and memory. The micro-architecture can be logically broken up into components such as an instruction decode unit, registers, execution units, caches, branch prediction units, reorder buffers, and so on. Some components, such as the instruction decode unit and registers, are essential to the correct operation of the processor while other units, such as caches, while not essential to correctness, are important to optimize some behavior such as performance. Each component can often be implemented in many different ways that result in different behavioral characteristics and resources.
To understand how a micro-architectural component can change the performance behavior of a processor, consider an instruction cache. A cache automatically stores data recently accessed from memory and routinely services future requests for that data as long as it is in the cache. Accessing the cache is faster than accessing the memory. Since the cache is smaller than memory, it relies on a replacement policy that decides what instructions to keep in the cache and what instructions to replace with newly accessed instructions. The first time some code is executed, that code is not in the instruction cache and must be obtained from memory. The second time the code is executed, there is a chance that it is in the cache in which case the access is faster. Since the cache is limited in size, it may be that the particular code in question may have been replaced before it is used again. Cache behavior is heavily dependent on the dynamic usage of that cache. Thus, without running the program and somehow modeling the instruction cache, it is very difficult to determine whether or not the code is in the cache.
There are many more components and features within a processor contributing to behavioral variance such as superscalar and out-of-order execution, branch prediction, parallel execution, and virtual memory. In addition to the processor, there are many more components within a computer system that also contribute to behavioral variance. Added together, there can be a significant amount of behavioral variation that are dependent on a large number of variables including the programs being currently run, the programs that ran in the past, and external events such as the arrival of a network packet or a keyboard stroke.
The most accurate model of a computer is the computer itself. It is often the case, however, that it is impractical and/or impossible to use the computer itself to predict its own behavior. For example, the computer is not available to be measured before it is manufactured. Running applications on an existing system and using its behavior to directly predict the behavior of a next generation system is generally inaccurate since the new system will be different than the old one.
Due to the complexity of computer systems, their behavior is generally predicted using simulators. Most simulators are written entirely in software and executed on regular computers. Simulators can model computer system behavior at a variety of levels. For example, some simulators only model the ISA and peripherals at a “functional” level, that is, at a detail level sufficient to implement functionality but not to predict timing. Such simulators are often able to boot operating systems and run unmodified applications and can be useful to provide visibility when debugging operating systems and software.
Other simulators model computer systems at a detail level sufficient to accurately predict the behavior of the computer system at a cycle-by-cycle level. Such simulators must accurately model all components that could potentially affect timing. They are often written by architects during the design of a computer system to help evaluate architectural mechanisms and determine their effect on overall performance. Most processors today are implemented in hardware description languages (HDL) that enable the specification of the processor in Register Transfer Logic (RTL). Such specifications can also be simulated very accurately.
There are, however, issues with cycle-accurate simulators. For the most part, they are extremely slow. Most truly cycle-accurate simulators run at approximately 10K cycles per second or slower. RTL cycle-accurate simulations run at a few cycles per second at best. Though computers have been getting faster, the complexity of the machines that they were simulating has also gone up, keeping simulation speed fairly constant over time. With the proliferation of chip multiprocessors (CMPs), however, it is likely that simulation performance will drop rapidly unless simulators can be efficiently parallelized. Simulating multiple processors obviously takes longer than simulating a single processor on the same host hardware resources.
Current simulator speeds are far too slow to run full operating systems and applications. For example, a simulator running at 10K cycles per second takes 402 days to simulate a two-minute OS boot. Such times are far too long, forcing users to extract kernels that are intended to accurately model longer runs. Such kernels, however, are difficult to chose and often do not exercise all of the behavioral complexity. It would be far easier if accurate simulators were fast enough to run full, unmodified operating systems and applications.
Thus, computer system simulation is a difficult problem with no satisfactory full solutions.
SUMMARY OF THE INVENTION
Simulation performance is improved using parallelism. A simulator is parallelized by partitioning it into a functional component and a behavior prediction component such as a timing component. The functional component simulates the simulated system at a functional level and passes execution path information to the behavior prediction component. The behavior prediction component can change the functional component execution path as is necessary to accurately model the behavior. Changing the functional component execution path may require asking the functional component to do so. Either component can be implemented in software or hardware. The two components execute in parallel on some parallel platform that contains processors, hardware or some combination of the two. The hardware used could be one or more FPGAs. This scheme can be used to simulate computer systems.
BRIEF DESCRIPTION OF THE DRAWINGS
The foregoing and other objects, features and advantages of the invention will be apparent from the following more particular description of preferred embodiments of the invention, as illustrated in the accompanying drawings in which like reference characters refer to the same parts throughout the different views. The drawings are not necessarily to scale, emphasis instead being placed upon illustrating the principles of the invention.
FIG. 1 shows a high level view of a partitioned simulator.
FIG. 2 shows a more detailed view of the timing model including a five stage pipelined processor, a memory controller, DRAM and a peripheral bus to which are attached a disk, a network interface, and a keyboard.
FIG. 3 provides the code that will be used in the examples shown in FIG. 3 and
FIG. 4. It illustrates how instructions would move through a standard five stage pipeline in which branches are resolved in the Execute stage.
FIG. 4 illustrates how instructions would move through a standard five stage pipeline in which branches are resolved in the Writeback stage.
DETAILED DESCRIPTION OF THE INVENTION
A description of example embodiments of the invention follows.
Simulation is a commonly used method to predict the behavior of a target system when measuring the target system itself is undesirable for a variety of reasons including target unavailability, target cost, or the inability to measure the target appropriately. Simulation is used in virtually all engineering and scientific fields and has enabled significant advances in almost all of the fields that use it. Many simulators are computer programs running on standard computers.
Simulation performance is very important. For many applications, a minimum simulation performance is required to make the simulator useful. Faster simulation enables longer simulated times and more experiments to be run in the same amount of time and consequently, lends more confidence to the simulation results.
Disclosed is a method to significantly improve simulation performance by appropriately parallelizing the simulator in a very scalable fashion, causing it to run quickly and efficiently on a parallel host.
One way to implement a simulator is to partition it into two models: a functional model and a behavior prediction model. The functional model implements the functionality of the target but does not predict behavior beyond the target's functionality. The behavior prediction model predicts the target's behavior or behaviors of interest but does not implement any functionality.
To illustrate how this partitioning works, we describe a simulator partitioned in this fashion where the target is a conventional sequential computer executing a standard instruction set architecture that assumes that an instruction is completely executed before the next instruction starts executing. The target's computational performance is data independent, meaning that the number of cycles through an ALU is constant given a certain operation. Assume also that the desired behavior to predict is the target performance for a certain application. Because we are predicting performance, we use the term “timing model” in place of behavior prediction model. We also assume a conventional in-order issue but either in-order or out-of-order execution mico-architecture, as the target processor's micro-architecture.
Given these assumptions, the simulator is partitioned into a functional model that simulates the ISA of the processor and the functionality of the memory system and all of the peripherals of the target. It executes programs that would execute on the target. A complete functional model executes unmodified programs and unmodified operating systems compiled for the target. It appears to be, in virtually all aspects other than performance, the target computer.
The timing model only models structures required to predict the performance of the target machine, such as delay elements and arbiters. For example, the timing model the timing of the memory hierarchy including caches, memory and disk, branch predictors, instruction schedulers and the number of ALUs in the Execute stage. It does not, however, implement any of the functionality of the target machine. Thus, it is incapable of executing the ADD ALU function in the Execute stage.
There are many advantages to such a partitioning. Because the timing model does not implement any functionality and the functional model does not implement any timing prediction, the combination which creates the complete simulator is far simpler than the real target. For example, for targets whose performance is not data-dependent, the timing model does not need to store cache data since the data values do not affect performance. In fact, data often does not need to pass through the timing model at all because the timing model does not need the data values to predict performance. Likewise, for a target that presents a flat memory model to software, the functional model does not need any model of the cache. Thus, for such target systems the cache data is completely eliminated from the simulator, saving simulation resources and reducing simulation implementation effort.
Another advantage of such a partitioning is reusability of the models. A functional model can be reused for any target whose functionality is the same as the functional model. For example, an x86 functional model could be used to for virtually any computer that supports the same variation of the x86 instruction set. Likewise, a timing model can be reused for a target with the same micro-architecture.
Yet another advantage of such a partitioning is the ease by which the models can be created and modified. In this example, a timing model consists of simple components such as FIFOs, CAMs, registers, memories and arbiters. Assuming data independent performance, no data computation is required, eliminating full ALUs and FPUs implementations and enabling them to be modeled by delay elements such as pipeline registers.
Since the model components are often quite simple, making changes is also often quite simple. It is often the case that changes in timing are introduced during implementation. For example, it may be discovered during implementation that an ALU takes four cycles instead of three cycles. Making such a change within a timing model is trivial; one simply adds a pipeline stage to the ALU. Functionality does not need to be repartitioned across four stages from three stages since the functionality is implemented elsewhere.
Likewise, the functional model can also be easily changed. Since the functional model is not concerned with modeling timing, adding a new instruction or modifying an old instruction is generally far simpler than if the model combined functionality and timing.
A functional model that runs at maximally high performance is an aggressive computer system itself, making its implementation as difficult as any target. Thus, maximum performance is often impractical. It is often the case, however, that making reasonable compromises in performance can result in substantial implementation savings. For example, a functional model could be implemented as a software-based full-system functional simulator or a simple microcoded processor. Selecting a pre-existing functional model can also dramatically reduce the overall implementation effort.
Somehow, the functional model and timing model must interact to simulate functionality and accurately predict timing. A baseline method is to have the functional model generate an instruction trace that is passed to the timing model that uses that instruction trace to predict performance. We call the path of instructions naturally produced by the functional model the “functional path” and the instruction fetch path of the target processor the “target path”. For now, we assume that the functional model generates an in-order instruction trace where every instruction is executed to completion before the next instruction starts executing and thus branches are perfectly resolved.
FIG. 1 is a high-level diagram of an embodiment of this invention. The functional model 100 generates an instruction stream 120 that is sent to the timing model 110. The timing model has a feedback path 130 back to the functional model for a variety of purposes that will be discussed later in the disclosure.
FIG. 2 shows a more detailed timing model 205 of one embodiment of the invention. The functional model 200 of this embodiment is shown for reference. This particular timing model models a five stage pipeline including Fetch 210, Decode 215, Execute 220, Memory 225 and Writeback 230 stages. A front side bus model 265 is connects the Memory stage model and the Memory Controller 240 model. The memory controller model 240 is attached to a DRAM model 235 and a peripheral bus model 245. The peripheral bus model is attached to a disk model 250, a network interface model 255 and a keyboard model 260. Note that there are more components modeled than just the processor itself to accurately predict the performance of the entire computer system, not just the processor. The functional model must also model the other components as well.
For a simple microcoded target processor that executes each instruction to completion before starting the next instruction, the functional path is equivalent to the target path. One possible implementation of the corresponding timing model reads each instruction from the functional model instruction trace and computes how much time each instruction would take. Thus, the timing model could be simply a lookup table that mapped each instruction to the number of cycles it takes to fully execute. If the target contains a single data cache, every memory operation would check to see if it hit in the cache and use that information to determine the amount of time the memory access took. Of course, cache replacement would have to be accurately modeled to determine whether an access hit or missed. The timing overhead to perform replacement would also need to be modeled.
For such a target, having the functional model pass an instruction trace to the timing model is sufficient for the timing model to accurately model performance. The timing model may pass aggregate data back to the functional model indicating that instructions have been retired for resource management and back-pressure purposes to ensure that the functional model does not overrun buffers.
A more aggressive target could complicate the interface between the functional and the timing model. Consider the classic five stage pipeline with Fetch, Decode, Execute, Memory and Writeback stages with a single cycle memory latency and no bypassing. For now assume a program with no branches. One possible timing model implementation would take instructions from the instruction trace into the Fetch stage. On each successive simulated cycle, that instruction would move through each of the stages if it was not stalled. The timing model must model stalls which, for this simple target, will occur only if there is a dependency on data that has not yet been written back to the register file.
Adding a blocking instruction and data cache is also straightforward. As each instruction passes through the Fetch stage and the Memory stage, a cache model is checked for a hit and either the instruction is stalled for the appropriate amount of time for the data to be fetched from memory and the cache to be updated, or the instruction passes to the next stage and the replacement bits within the cache model are updated. Non-blocking caches simply need to allow instructions that are not dependent on a pending miss to proceed. The timing model simply needs to add support for the appropriate cache models and permit those cache models to stall the pipeline.
If there are branches within the instruction stream, however, a potential problem could occur. In order to keep the pipeline full, branches must be predicted because the direction that the branch takes cannot be known until the appropriate condition code is generated which could occur in the Execute or Memory stage (we assume that condition code updates are aggressively bypassed) meaning that the branch could be resolved in the Decode or Execute stages. Assume that branches are always resolved in the Execute stage. Assume also that branches are always predicted not-taken. In that case, the functional path could sometimes be different than the target path because the target path would partially process wrong path instructions between the branch being mis-predicted and the branch being resolved.
It is important for the timing model to be able to determine whether or not the functional path is identical to the target path. It can do that by modeling the program counter (PC) and comparing its expected PC with the instruction address passed for each instruction in the instruction trace. If branch prediction is used, the expected PC is updated according to the branch prediction algorithm. Since the expected PC is the PC that would be used by the target, the expected PC is used to address the instruction cache.
A branch is determined to be mispredicted by comparing the branch target address from the functional path instruction stream to the expected PC. When the branch misprediction is resolved, the timing model expected PC will be forced to the value of the right path PC (which is the same as the functional path PC) following the branch.
The functional model passes functional path instructions which, given our assumptions, is the in-order non-speculative path. The target, however, would execute a predicted-not-taken path that may cause different stalls due to the different dependencies than the functional path.
FIG. 3 illustrates how instructions would be processed by a five stage pipeline with predicted-not-taken branch prediction assuming that branches are resolved in the Execute stage. The static program 360 is given as a series of address/instruction pairs. The functional path 370 is given. The target path is given both in 380 and in time steps 390. Each of the five columns in 390 is one of the five stages of the pipeline. Each successive row represents a successive cycle. The branch-on-negative (BRn) instruction starts in the Fetch stage 300 when T=1, moves to the Decode stage 302 when T=2, to the Execute stage 304 when T=3, to the Memory stage 306 when T=4 and to the Writeback stage 308 when T=5. Instruction address 11 (310, 312, 314, 316, 318) and Instruction address 12 (320, 322, 324, 328, 330) are speculatively fetched and decoded using the predicted-not-taken prediction strategy. When the branch reaches the Execute stage, it is resolved and determines that the two following instructions are mispeculated and cancels them (314, 316, 318, 322, 324, 328 and 330). Instruction address 20 (332, 334, 336, 338), 21 (340, 342, 344), 22 (346, 348) and 23 (350) are processed by the pipeline. Thus, the target path is Instruction addresses 10, 11, 12, 20, 21, 22, 23.
The functional path, however, is 10, 20, 21, 22, 23. It does not contain Instruction address 11 and 12 because the branch is resolved by the functional model before the next instruction is generated. Thus, the functional path differs from the target path. This difference could introduce inaccuracies if the functional path is always used as is and cannot be modified.
In the five stage pipeline case where branches are resolved in the Execute stage, however, differences in pipeline stalls are impossible. The first time a stall could occur is in the instruction following the branch which is resolved by the Execute stage. Since misspeculation is detected in the Execute stage and the misspeculated instructions promptly killed, no misspeculated instructions will reach the Execute stage and thus the stalling characteristics will accurately model the target. We are assuming that no state is being modified in Decode and that Fetch only modifies the instruction cache to reflect the next instruction fetch. The Fetch stage has fetched from the expected PC and thus the modifications it has generated by accessing the instruction cache are correct.
If, however, branches are resolved in the Writeback stage and there is no data bypassing, it is possible that the difference between the functional path and the target path could create an inaccuracy in the simulation. FIG. 4 shows an example of such a possibility. The code is the same as in FIG. 3. Because branches are not resolved until the Writeback stage, Instruction addresses 11 (410, 412, 414, 416, 418) 12 (420, 422, 424, 426, 428) and 13 (430, 432, 434, 436) are fetched and processed due to branch mis-prediction. In time T=4, a dependency is detected between Instruction address 11 and 12. Thus, a bubble (424, 426, 428) is introduced into the pipeline. If the functional path instructions were used, however, that bubble would have never been introduced because the functional path instructions do not have any data dependencies. Since, at this point, we only have in-order path instructions in the functional path instruction stream, we cannot correctly determine whether or not that stall should occur. Thus, we would need the target path instruction stream that would include wrong path instructions to accurately model performance.
The functional path, however, does not naturally contain the wrong path instructions. Also, the timing model does not, in general, have the capability to generate the wrong path instructions on its own. Thus, the functional model must somehow determine when to generate wrong path instructions, generate those wrong path instructions and return to the functional path once the timing model determines that the mis-speculated branch has been resolved.
Because different micro-architectures will misspeculate differently and resolve misspeculations differently, the functional model must get misspeculation information from the timing model since the functional model knows nothing about the target micro-architecture. Thus, the timing model informs the functional model when a misspeculation occurs and what the misspeculated branch target address is. It also informs the functional model when the misspeculated branch is resolved. The functional model must produce the correct wrong path instructions when notified of a misspeculation and then switch back once it is notified that the branch is resolved. Of course, multiple misspeculated branches implies that switching back after resolving a misspeculation could continue wrong path execution for an earlier branch.
One way for the functional model to generate wrong path instructions is for it to support the ability to “rollback” to a branch and then continue to the next instruction as instructed by the timing model. One implementation of such a rollback operation can be accessed using a set_pc command that takes two arguments, a dynamic instruction number and the instruction address to force that dynamic instruction to. Given such an interface, the timing model calls the functional model when necessary to indicate a misspeculated branch as well as the resolution of the branch.
To generalize, there is a potential issue if the instruction path naturally generated by the functional model (called the functional path) is different than the instruction path that would have been generated by the target (called the target path). As we saw in our five stage in-order pipeline where branches are resolved in the Execute stage, there are cases when such a difference does not matter. The five stage in-order pipeline where branches are resolved in the Writeback stage example, however, demonstrated why such divergences can matter. In general, modern branch-predicted, out-of-order microprocessor targets also have problems with functional/target divergence. Though most standard branch-predicted microprocessors retire instructions in program order, they generally implement branch prediction. Target path instructions are also needed in this case to predict performance.
Given an in-order functional model modeling a standard out-of-order target, the functional model will often not execute instructions in the same order as the target. Most target processors, however, issue instructions in order and only execute out of order. Thus, modulo branch misspeculation, an in-order path is the required target path. Forcing the functional model to execute out-of-order is generally unnecessary from a functional model correctness point of view (but would still be functionally correct since all the dependencies would be maintained) but would generate an incorrect instruction stream. In fact, without the in-order instruction stream, the timing model would not be able to reorder those instructions correctly. We revisit instruction reordering when discussing parallel targets.
If the ISA being modeled permits, it is possible for different functional models to generate different functional paths. For example, assume an ISA that permits flexibility in choosing which instruction out of a pool of instructions to execute next. For example, imagine a Very-Long-Instruction-Word (VLIW) instruction set that specifies three instructions per long instruction. A reasonable ISA specification may state that a correct execution order would allow those three instructions to be executed in any arbitrary order. One functional model may choose one order and another functional model may choose another. Even in such a case, such differences do not matter unless the functional correctness is broken or the timing model would require the instructions in a different order. A timing model could be written in such a way to handle such out-of-orderness in the functional stream.
A key insight is that branch prediction works because most branches are predicted correctly. Otherwise, the overhead of recovering from a misspeculated branch (throwing away the effects of the wrong path instructions and restarting from the misspeculated branch) could make branch prediction a performance loss.
To summarize up to this point, the disclosed method describes a simulator that generates a target path by starting with a functional path and then permitting the timing model to inform the functional model of differences between the two paths and how to make them consistent. Because the functional path is often the same as the target path, however, the timing model rarely changes the functional path.
A key insight of the disclosed method is the observation that since round trip communication between the functional model and timing model is minimized, such a functional/timing partitioned simulator is well suited to be run on a parallel host, where the functional model and the timing model run in parallel. The method takes advantage of the fact that the functional path is often identical to the target path. When the functional path is identical to the target path, the simulator is driven by the functional model with no feedback required from the timing model. Only when the functional path and the target path diverge does the timing model need to communicate with the functional model to steer the functional model down the target path and thus generate the correct instructions to accurately predict performance.
A simple parallelized host using this method could run the functional model in one processor and the timing model in another processor. For many targets and hosts, however, such an implementation is unlikely to result in better performance. The reason is that for many micro-architectures, the timing model consumes far more time than the functional model and thus splitting the two models only removes the performance burden of the functional model from the processor running the timing model while introducing communication costs.
The timing model itself could be parallelized and run on multiple host processors. Depending on the latency and bandwidth between the host processors, this technique could significantly improve performance. Most timing models, however, would require very frequent communication which could overload most current processors. As multiple cores on a single processor die become more prevalent, however, the communication may become tractable.
The timing model often models massively parallel hardware structures. High performance simulation of massively parallel structures almost demands a massively parallel host. A good massively parallel host is hardware.
The preferred embodiment further parallelizes the functional/timing partitioned simulator by implementing the timing model in hardware. Field programmable gate arrays (FPGAs) are an excellent hardware host since they are reprogrammable, fairly dense and fairly fast. Since many timing models do not need to model the data path, they generally consume very few hardware resources and thus can often fit into a single FPGA or a few FPGAs.
Hardware designed to implement a functional model is, by our definition, a computer system. The very best hardware architectures for executing instructions quickly are processors. Thus, the functional model will be hosted on one or more processors in a computer system. The host could either use a “hard” processor that is implemented directly in hardware, a “soft” processor that is implemented in an FPGA fabric or a software functional model simulator. Regardless of the underlying hardware, the functional model must be able to generate a trace for the timing model and must have support for the timing model to change the instruction execution path to generate the target path.
The preferred embodiment implements the functional model as a software simulator running either on a hard processor or a soft processor. Existing full system simulators that already run unmodified software and operating systems can be modified to produce an instruction trace and provide the timing model the ability to modify the instruction execution path. Though such modifications are non-trivial, the fact that such an approach leverages existing simulators with full system execution capabilities makes this approach very attractive.
A soft processor that directly executes the desired target system and provides tracing and the ability to modify instruction execution is another possible functional model that will likely run quickly and could be available in the near future. Implementing such a soft processor, however, can be quite difficult when modeling complex ISAs such as Intel's x86 and complex systems. Thus, though such a soft processor may eventually be a better solution, the potentially tremendous effort of implementing the soft processor will likely delay the first implementations of such an approach.
It is interesting to note that if the simulator runs quickly, the functional path is frequently equivalent to the timing path. If they are generally equivalent, the functional model rarely needs feedback from the timing model and thus rarely encounters the functional path→mis-speculation→wrong path or wrong-path→resolution→functional path loop that has significant impact on performance.
A system partitioned in such a fashion is capable of running in excess of ten million instructions per second when the functional model runs on a standard off-the-shelf microprocessor and the timing model runs on an FPGA. Such a system can run at these speeds simulating a complex ISA like the Intel x86 ISA, boots unmodified operating systems and runs unmodified applications and can be fully cycle accurate. Truly cycle accurate pure-software simulators of similar complexity modeling the x86 ISA run about one thousand times slower or at about ten thousand cycles/instructions per second and do not generally boot operating systems.
In addition, because the timing model runs on an FPGA, statistics gathering can be done within the timing model using dedicated hardware. Thus, even extensive statistics gathering can be done with little to no impact to performance. Gathering statistics on a software simulator consumes host processor cycles and thus has a significant impact on simulation performance. The greater the number of statistics gathered, the slower the simulation.
For simplicity the above description is focused on a standard sequential microprocessor-based system. This method is equally applicable to parallel targets that contain multiple processors or processor cores. To illustrate, assume a two processor shared memory target system. Each processor must be functionally modeled by the functional model. The functional model could be implemented in a variety of ways including by two host processors or by a single multi-threaded host processor. In the former case, care must be taken to handle I/O operations to shared devices correctly which can be done by ensuring that shared I/O devices can be rolled back by the timing model. We assume an in-order functional model. They will each access a global shared memory which we assume for now is uncached by the host processor.
The timing model back-pressures each processor's functional model to ensure that it does not get too far ahead of the other processor. Thus, each functional model is executing instructions close in simulated time to when it would be executing those instructions on a real target.
Assuming that nothing in the system ever read/write the same memory location close enough in simulated time to make precise ordering important, the two processors can execute as if they were each a uniprocessor system. The only time there is a potential issue is if one device (a processor or another bus device) writes a location that another device is reading at approximately the same time and the functional model chooses the incorrect ordering for the given target.
The timing model can detect that the functional model incorrectly ordered memory operations using a variety of methods. One simple method is to include the read/written data in the instruction trace and compare the read value with the value it should have read given that a write to the same address has not yet retired. One simple implementation of such a method uses an associative structure to track the read/write reorderings. In addition, if there is a read/write mis-order, if the write wrote the same value that was originally in the read memory location, there is no error.
If an incorrect ordering is detected, rollback can be used to correct the problem. Once a problem is detected, the timing model immediately freezes since it is possible that the instruction sequence it has been operating with is incorrect since the reordering might actually result in a different value returned in response to a read that could then result in a different instruction sequence. However, since the target would not have read that value until that instruction was executed and because until that value was read we could not branch on the value and thus the branches depending on that value must have either been predicted or stalled, the timing model is not corrupted. By then having the functional model feed the corrected addresses to the timing model, the timing model can resume from where it was frozen.
The described parallel target simulator can model a target that implements sequential consistency. To model a target with certain weaker models would require the ability for the timing model to specify a non-program order of executing some instructions. The timing model can very easily track when instructions are actually executed and pass that information to the functional model in the cases where instructions actually need to be executed in that order in order to achieve functional correctness.
A very weak memory model, where reads and writes to the same location can get out of order, may require modeling caches that are not always coherent. There is no reason why cache data cannot be modeled in the timing model and thus such weak memory models can be simulated. One strategy is to model the data in DRAM local to the functional model and have the timing model maintain the cache coherency.
The described method does not address data speculation, where data values are predicted and the program runs assuming that data. Data speculation can also be handled by the described method, but the data speculation mechanism needs to be accurately modeled with data so that a mis-speculation can be detected and corrected using rollback.
Note that the functional model providing the initial path and the timing model modifying that path is very general and can handle virtually any sort of target path. Thus, though we described branch prediction, parallel targets and data speculation, the technique can be applied in many other areas.
The initial description assumed a very strict separation of the functional model and timing model. It may be advantageous to relax that separation. For example, implementing a branch predictor predictor in the functional model would allow the functional model to predict a misspeculation and act on that prediction, sending wrong path instructions before being asked for them. The functional model could also guess when the branch would be resolved. Only if the functional model mispredicted would a round-trip communication be in the critical path.
Another place where a relaxed separation could benefit is using the timing model to store state for the functional model. For example, the timing model could store state to assist in rollback. The functional model could pass the old value of registers and memory as they are being written. If the functional model needed to rollback, it could get the old state, nicely formatted and redundancy eliminated, from the timing model.
Though this disclosure has focused on performance as the desired behavior to predict, other behaviors such as dynamic power prediction can also be done using similar methodologies. Additional data might need to be passed through the behavior prediction model, but the same methodology of using a functional model to generate a functional path which can then be modified by the behavioral prediction model still applies.
Though this disclosure has focused on computer targets, almost any target that can be separated into a functional model and a behavioral model could be simulated in this fashion. Thus, many silicon chips could be simulated in this fashion. With the appropriate hooks in place, previous generations of a chip could serve as a functional model for a next generation design.
For example, let us examine an ingress traffic manager that is commonly found in networking gear. A traffic manager interfaces with a network processor that classifies the packet and determines the destination or destinations of that packet and a switch fabric that moves that packet to the appropriate output port or ports. The traffic manager simply accepts packets marked with their destinations and passes them through to the fabric. If the fabric can always accept all of the packets the traffic manager passes, the traffic manager is essentially a wire. If, however, the fabric cannot, either temporarily or persistently, accept packets, the traffic manager must decide which packets to submit to the fabric and which ones to hold back and, if necessary, drop.
Thus, an ingress traffic manager might do the following: receives packets, buffers them, determine which packets to send and determine which packets to drop. Functionally, the traffic manager could remain the same even though different implementations might have very different performance characteristics.
It is possible to partition a traffic manager simulator into a functional model and a timing model, where the functional model indicates what it does (corresponding to the instruction stream) to the timing model and the timing model predicting time. The timing model may notice that the functional model does not have a particular piece of information (such as the fact that a packet is fully queued which may be a requirement before inserting that packet into the fabric) and thus force the functional model to rollback and re-execute with a corrected version of its information. Thus, the disclosed method can be used to simulate targets other than a computer system.
While this invention has been particularly shown and described with references to example embodiments thereof, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the scope of the invention encompassed by the appended claims.
Claims (17)
1. A method of performing a simulation of a target digital system, using a simulator, the method comprising:
providing a simulator model of the target digital system partitioned into a functional component that models the target digital system's functionality to simulate the target digital system at function levels and a behavior prediction component that models structures required to predict the behavior of the target digital system;
executing the functional and behavior prediction components;
passing an output of the functional component to the behavior prediction component that uses that output to predict behavior;
comparing information from the functional component output with behavior predicted by the behavior prediction component; and
when the output of the functional component is inconsistent with the predicted behavior, providing information from the behavior prediction component to the functional component to correct the functional component output.
2. A method as claimed in claim 1, wherein at least one component is implemented in hardware.
3. A method as claimed in claim 2, wherein the hardware comprises a field programmable gate array (FPGA).
4. A method as claimed in claim 1, wherein the functional component is implemented in software.
5. A method as claimed in claim 4, wherein the behavior prediction component is implemented in hardware.
6. A method as claimed in claim 5, wherein the hardware comprises an FPGA.
7. A method as claimed in claim 6, wherein the simulator simulates a computer system.
8. A method as claimed in claim 1, wherein the behavior prediction component is a timing model that predicts performance.
9. A method of performing a simulation of a target digital system, using a simulator, the method comprising:
providing a simulator model of the target digital system partitioned into a functional component that models the target digital system's functionality to simulate the target digital system at functional levels and a behavior prediction component that models structures required to predict the performance of the target digital system;
executing the functional and behavior prediction components;
passing an instruction trace of the functional component to the behavior prediction component that uses that instruction trace to predict behavior;
comparing information from the functional component instruction trace with behavior predicted by the behavior prediction component; and
when the instruction trace of the functional component is inconsistent with the predicted behavior, providing information from the behavior prediction component to the functional component to correct the functional component instruction trace.
10. A method as claimed in claim 9, wherein at least one component is implemented in hardware.
11. A method as claimed in claim 10, wherein the hardware comprises a field programmable gate array (FPGA).
12. A method as claimed in claim 1, wherein the functional component is implemented in software.
13. A method as claimed in claim 12, wherein the behavior prediction component is implemented in hardware.
14. A method as claimed in claim 13, wherein the hardware comprises an FPGA.
15. A method as claimed in claim 14, wherein the simulator simulates a computer system.
16. A method as claimed in claim 9, wherein the functional component and behavior prediction component are executed in parallel.
17. A method as claimed in claim 1, wherein the functional component and behavior prediction component are executed in parallel.
US11633657 2005-12-02 2006-12-04 Simulation method Active 2029-01-14 US7840397B2 (en)
Priority Applications (2)
Application Number Priority Date Filing Date Title
US74158705 true 2005-12-02 2005-12-02
US11633657 US7840397B2 (en) 2005-12-02 2006-12-04 Simulation method
Applications Claiming Priority (3)
Application Number Priority Date Filing Date Title
US11633657 US7840397B2 (en) 2005-12-02 2006-12-04 Simulation method
US12950471 US8494831B2 (en) 2005-12-02 2010-11-19 Method to simulate a digital system
US13922728 US8855994B2 (en) 2005-12-02 2013-06-20 Method to simulate a digital system
Related Child Applications (1)
Application Number Title Priority Date Filing Date
US12950471 Continuation US8494831B2 (en) 2005-12-02 2010-11-19 Method to simulate a digital system
Publications (2)
Publication Number Publication Date
US20070150248A1 true US20070150248A1 (en) 2007-06-28
US7840397B2 true US7840397B2 (en) 2010-11-23
Family
ID=38195020
Family Applications (3)
Application Number Title Priority Date Filing Date
US11633657 Active 2029-01-14 US7840397B2 (en) 2005-12-02 2006-12-04 Simulation method
US12950471 Active US8494831B2 (en) 2005-12-02 2010-11-19 Method to simulate a digital system
US13922728 Active US8855994B2 (en) 2005-12-02 2013-06-20 Method to simulate a digital system
Family Applications After (2)
Application Number Title Priority Date Filing Date
US12950471 Active US8494831B2 (en) 2005-12-02 2010-11-19 Method to simulate a digital system
US13922728 Active US8855994B2 (en) 2005-12-02 2013-06-20 Method to simulate a digital system
Country Status (1)
Country Link
US (3) US7840397B2 (en)
Cited By (3)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8355934B2 (en) 2010-01-25 2013-01-15 Hartford Fire Insurance Company Systems and methods for prospecting business insurance customers
US8359209B2 (en) 2006-12-19 2013-01-22 Hartford Fire Insurance Company System and method for predicting and responding to likelihood of volatility
US9881340B2 (en) * 2006-12-22 2018-01-30 Hartford Fire Insurance Company Feedback loop linked models for interface generation
Families Citing this family (9)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7840397B2 (en) 2005-12-02 2010-11-23 Derek Chiou Simulation method
US8930683B1 (en) 2008-06-03 2015-01-06 Symantec Operating Corporation Memory order tester for multi-threaded programs
US8531197B2 (en) * 2008-07-17 2013-09-10 Freescale Semiconductor, Inc. Integrated circuit die, an integrated circuit package and a method for connecting an integrated circuit die to an external device
US20100057427A1 (en) 2008-09-04 2010-03-04 Anthony Dean Walker Simulated processor execution using branch override
US20100250227A1 (en) * 2009-03-31 2010-09-30 Board Of Regents The University Of Texas System Detecting and correcting out-of-order state accesses using data
US9268573B2 (en) * 2012-11-02 2016-02-23 Michael Rolle Methods for decoding and dispatching program instructions
GB201309765D0 (en) * 2013-05-31 2013-07-17 Advanced Risc Mach Ltd Data processing systems
CN104123172A (en) * 2014-07-17 2014-10-29 南车株洲电力机车研究所有限公司 Double-fed wind power simulation system and circuit simulation module thereof
US9921859B2 (en) * 2014-12-12 2018-03-20 The Regents Of The University Of Michigan Runtime compiler environment with dynamic co-located code execution
Citations (6)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6212489B1 (en) * 1996-05-14 2001-04-03 Mentor Graphics Corporation Optimizing hardware and software co-verification system
US20020107678A1 (en) * 2001-02-07 2002-08-08 Chuan-Lin Wu Virtual computer verification platform
US20020138244A1 (en) * 1999-09-30 2002-09-26 Meyer Steven J. Simulator independent object code HDL simulation using PLI
US20030191615A1 (en) * 2001-06-17 2003-10-09 Brian Bailey Synchronization of multiple simulation domains in an EDA simulation environment
US20040111708A1 (en) * 2002-09-09 2004-06-10 The Regents Of The University Of California Method and apparatus for identifying similar regions of a program's execution
US20060031791A1 (en) * 2004-07-21 2006-02-09 Mentor Graphics Corporation Compiling memory dereferencing instructions from software to hardware in an electronic design
Family Cites Families (4)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6182258B1 (en) * 1997-06-03 2001-01-30 Verisity Ltd. Method and apparatus for test generation during circuit design
US7328195B2 (en) * 2001-11-21 2008-02-05 Ftl Systems, Inc. Semi-automatic generation of behavior models continuous value using iterative probing of a device or existing component model
US7778715B2 (en) * 2005-01-31 2010-08-17 Hewlett-Packard Development Company Methods and systems for a prediction model
US7840397B2 (en) 2005-12-02 2010-11-23 Derek Chiou Simulation method
Patent Citations (6)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6212489B1 (en) * 1996-05-14 2001-04-03 Mentor Graphics Corporation Optimizing hardware and software co-verification system
US20020138244A1 (en) * 1999-09-30 2002-09-26 Meyer Steven J. Simulator independent object code HDL simulation using PLI
US20020107678A1 (en) * 2001-02-07 2002-08-08 Chuan-Lin Wu Virtual computer verification platform
US20030191615A1 (en) * 2001-06-17 2003-10-09 Brian Bailey Synchronization of multiple simulation domains in an EDA simulation environment
US20040111708A1 (en) * 2002-09-09 2004-06-10 The Regents Of The University Of California Method and apparatus for identifying similar regions of a program's execution
US20060031791A1 (en) * 2004-07-21 2006-02-09 Mentor Graphics Corporation Compiling memory dereferencing instructions from software to hardware in an electronic design
Non-Patent Citations (11)
* Cited by examiner, † Cited by third party
Title
Austin, T., et al., "SimpleScalar: An Infrastructure for Computer System Modeling," IEEE, pp. 59-67, (Feb. 2002).
Bengt Werner et al. Simics: A Full System Simulation Platform 2002 IEEE, 0018-9162/02. *
Binkert, N. L., et al., "Network-Oriented Full-System Simulation Using M5,"CAECW, pp. 1-8, (Feb. 2003).
Carl J. Mauer, Mark D. Hill, David A. Wood Full-System Timing-First Simulation Proceedings of the 2002 ACM Sigmetrics international conference on Measurement and modeling of computer systems, pp. 108-116, ISBN: 1-58113-531-9. *
Emer, J., et al., "Asim: A Performance Model Framework," IEEE, pp. 68-76, (2002).
Jefferson, et al., "Distributed Simulation and the Time Warp Operating System," Proceedings of the 11th, ACM, pp. 77-93 (1987).
Jefferson, et al., "Virtual Time," ACM Transactions on Programming Language and Systems, vol. 7, No. 3, pp. 404-425 (Jul. 1985).
Mauer, C.J., et al., "Full-System Timing-First Simulation," ACM Sigmetrics Conference on Measurement and Modeling of Computer Systems, pp. 1-9, (Jun. 2002).
Moudgill, M., et al., "Environment for PowerPC Microarchitecture Exploration," IEEE, pp. 15-25, (May-Jun. 1999).
Schnarr, E., et al., "Fast Out-of-Order Processor Simulation Using Memoization," ASPLOS-VIII, pp. 1-12, (Oct. 1998).
Todd Austin, Eric Larson, Saugata Chatterjee MASE: A Novel Infrastructure for Detailed Microarchitectural Modeling ISPASS-2001. *
Cited By (6)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8359209B2 (en) 2006-12-19 2013-01-22 Hartford Fire Insurance Company System and method for predicting and responding to likelihood of volatility
US8571900B2 (en) 2006-12-19 2013-10-29 Hartford Fire Insurance Company System and method for processing data relating to insurance claim stability indicator
US8798987B2 (en) 2006-12-19 2014-08-05 Hartford Fire Insurance Company System and method for processing data relating to insurance claim volatility
US9881340B2 (en) * 2006-12-22 2018-01-30 Hartford Fire Insurance Company Feedback loop linked models for interface generation
US8355934B2 (en) 2010-01-25 2013-01-15 Hartford Fire Insurance Company Systems and methods for prospecting business insurance customers
US8892452B2 (en) * 2010-01-25 2014-11-18 Hartford Fire Insurance Company Systems and methods for adjusting insurance workflow
Also Published As
Publication number Publication date Type
US8855994B2 (en) 2014-10-07 grant
US20110066419A1 (en) 2011-03-17 application
US20130282356A1 (en) 2013-10-24 application
US8494831B2 (en) 2013-07-23 grant
US20070150248A1 (en) 2007-06-28 application
Similar Documents
Publication Publication Date Title
Heckmann et al. The influence of processor architecture on the design and the results of WCET tools
Mukherjee et al. Detailed design and evaluation of redundant multi-threading alternatives
Martínez et al. Cherry: Checkpointed early resource recycling in out-of-order microprocessors
Sherwood et al. Time varying behavior of programs
Velev et al. Formal verification of superscale microprocessors with multicycle functional units, exception, and branch prediction
US6059835A (en) Performance evaluation of processor operation using trace pre-processing
US5226130A (en) Method and apparatus for store-into-instruction-stream detection and maintaining branch prediction cache consistency
US6934832B1 (en) Exception mechanism for a computer
Vajapeyam et al. Improving superscalar instruction dispatch and issue by exploiting dynamic code sequences
US8127121B2 (en) Apparatus for executing programs for a first computer architechture on a computer of a second architechture
US7065633B1 (en) System for delivering exception raised in first architecture to operating system coded in second architecture in dual architecture CPU
US20090150890A1 (en) Strand-based computing hardware and dynamically optimizing strandware for a high performance microprocessor system
US5758112A (en) Pipeline processor with enhanced method and apparatus for restoring register-renaming information in the event of a branch misprediction
Bose et al. Performance analysis and its impact on design
US20130117541A1 (en) Speculative execution and rollback
US20090204785A1 (en) Computer with two execution modes
Mutlu et al. Runahead execution: An alternative to very large instruction windows for out-of-order processors
Akkary et al. Checkpoint processing and recovery: Towards scalable large instruction window processors
Purser et al. A study of slipstream processors
Thesing Safe and precise WCET determination by abstract interpretation of pipeline models
Skadron et al. Branch prediction, instruction-window size, and cache size: Performance trade-offs and simulation techniques
US5615357A (en) System and method for verifying processor performance
US20120297163A1 (en) Automatic kernel migration for heterogeneous cores
US20030149862A1 (en) Out-of-order processor that reduces mis-speculation using a replay scoreboard
US20090217020A1 (en) Commit Groups for Strand-Based Computing
Legal Events
Date Code Title Description
FPAY Fee payment
Year of fee payment: 4
MAFP
Free format text: PAYMENT OF MAINTENANCE FEE, 8TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1552)
Year of fee payment: 8
|
__label__pos
| 0.567732 |
Build Applications with Meteor
Book description
Build a variety of cross-platform applications with the world’s most complete full-stack JavaScript framework— Meteor
About This Book
• Develop a set of real-world applications each exploring different features of Meteor
• Make your app more appealing by adding reactivity and responsiveness to it
• Work with the most powerful feature of Meteor—the “full stack reactivity”—through building real-time applications with many third party libraries
• Who This Book Is For
If you are a developer who is looking forward to taking your application development skills with Meteor to next level by getting your hands-on different projects, this book is for you.
What You Will Learn
• See how Meteor fits in the modern web application development by using its reactive data system
• Make your front-end behave consistently across environments by implementing a predictable state container with Redux
• Get familiar with React and overview of Angular 2
• Add a map to your application with a real-time geolocation
• Plugin into Meteor social media APIs like Twitter’s streaming and Facebook’s Messenger
• Add search functionality from scratch to your existing app and data
• Add responsiveness with Bootstrap 4 and Google’s Material Design using Less and Sass
• Distribute your data across machines and data centers by adding Apache Cassandra to your existing stack.
• Learn how to scale your microservices with the high performant language neutral framework gRPC.
• Learn how to query multiple data sources using GraphQL.
• In Detail
This book starts with the basic installation and overview of the main components in Meteor. You’ll get hands-on multiple versatile applications covering a wide range of topics from adding a front-end views with the hottest rendering technology React to implementing a microservices oriented architecture.All the code is written with ES6/7 which is the latest significantly improved JavaScript language. We’ll also look at real-time data streaming, server to server data exchange, responsive styles on the front-end, full-text search functionality, and integration of many third-party libraries and APIs using npm.
By the end of the book, you’ll have the skills to quickly prototype and even launch your next app idea in a matter of days.
Style and Approach
This book takes an easy-to-follow project-based approach. Each project starts with the goal of what you will learn and an overview the technologies used.
Table of contents
1. Preface
1. What this book covers
2. What you need for this book
3. Who this book is for
4. Conventions
5. Reader feedback
6. Customer support
1. Downloading the example code
2. Downloading the color images of this book
3. Errata
4. Piracy
5. Questions
2. Foundation of Meteor
1. Setting up the development environment
2. Building a Meteor app
3. The frontend with React
1. The React's state
1. Adding state to a stateless function component
2. Inheritance versus composition
3. Adding a state to a component
4. Meteor with React
1. Adding and removing atmosphere packages in Meteor
2. Integrating React with Meteor's reactive data system
3. Explore MongoDB in the Meteor shell
4. Publishing and Subscribing
1. Improvements in the current code
4. Summary
3. Building a Shopping Cart
1. Creating the project structure
2. On the server
3. Building the application components
1. The ProductsContainer
1. PropTypes
2. The CartContainer
4. Adding router to the application
1. App.js
2. ProductComponent.js
3. The data containers
1. BooksContainer.js
2. MusicContainer.js
5. Meteor methods
1. Removing item from the cart
2. Updating the quantity of an item in the cart
3. Let's create another method that will calculate the cart's total price
6. Considerations for scalability
1. Basic validations on the server
2. Defining a schema
3. Defaults
7. Summary
4. Style Your React Components with Bootstrap and Material Design
1. Mobile first
1. Making it mobile friendly!
2. Modular CSS with LESS
1. Test it out!
3. Modular CSS with Syntactically Awesome StyleSheets
4. Bootstrap and Meteor
5. Using CSS modules with Meteor
6. Meteor and webpack styling the shopping cart
1. Test it out!
2. Test it out!
7. Styling the shopping cart with Material Design Lite
1. The grid
8. Summary
5. Real-Time Twitter Streaming
1. Twitter streaming
1. The application structure
2. Meteor with Redux
1. Redux and pure functions
2. The Redux parts
3. Why do we need Redux when we have Minimongo on the client?
3. Building the App
1. Folder structure client
2. Getting the data from the collection
4. Async actions in Redux
5. Creating the App components
6. Connecting the Redux store with the React components
1. The containers and the components of the App
2. The Filter components
3. Tweets component
4. The Sentiment component
5. On the Server
6. Test it out and improve it!
7. Summary
6. Developing Kanban Project Management Tool
1. Drag and drop in React
1. Test it out!
2. Building the App
3. The reducer function
4. Building the Modal
1. Test it out!
2. Higher-Order Components
3. Test it out!
5. Summary
7. Building a Real-Time Search Application
1. Importing the data
2. Index a text field
3. Try it out!
4. Building the app
1. Test it Out!
5. Summary
8. Real-Time Maps
1. Building the App
1. The server side
2. Test it out!
2. Summary
9. Build a Chatbot with Facebook’s Messenger Platform
1. Building the app
1. Training the bot
2. Moving the chatbot to the Meteor app
3. Test it out and improve it!
4. Adding Cassandra to our stack
5. Adding GraphQL to the stack
2. Summary
10. Build Internet of Things Platform
1. What is gRPC?
1. Test it out!
2. Building the apps
1. Test it out!
2. Test it out!
3. Test it and improve it!
3. Summary
Product information
• Title: Build Applications with Meteor
• Author(s): Dobrin Ganev
• Release date: May 2017
• Publisher(s): Packt Publishing
• ISBN: 9781787129887
|
__label__pos
| 0.999802 |
Altcademy - a Forbes magazine logo Best Coding Bootcamp 2023
How to use .ai files in ReactJS
Getting Started with .ai Files in ReactJS
Suppose you're working on a ReactJS project, and you've been handed a bunch of .ai files. These files are Adobe Illustrator files, a type of vector graphics file that's commonly used in graphic design. Now, you might be wondering, "How do I use these in my ReactJS application?" Don't worry; you're not alone. We'll walk through this together.
What are .ai Files?
Before diving into the coding part, it's important to understand what .ai files are. They're essentially a type of file that Adobe Illustrator uses. These files are unique because they can be resized without losing any image quality. This makes them perfect for designing logos, icons, and other visual elements that need to scale across different device screens.
Think of it like a rubber band. You can stretch it out to be much larger than its original size, and it won't become distorted or lose its shape. Similarly, .ai files can stay crisp and clear, no matter how you resize them.
Converting .ai Files to SVG
To use .ai files in ReactJS, we first need to convert them into a format that ReactJS can understand. The most convenient format for this is SVG (Scalable Vector Graphics). Like .ai files, SVGs are also vector images that can be scaled without losing quality.
There are many online tools available to convert .ai files to SVG. One such tool is CloudConvert. Navigate to their website, upload your .ai file, select SVG as the output format, and click convert.
Once the conversion is done, you'll have an SVG file that's ready to be used in your ReactJS application.
Using SVGs in ReactJS
Now that we have our SVG file, it's time to use it in our application. There are two main ways to use SVGs in ReactJS: inline SVG and SVG as an image source.
Inline SVG
Inline SVG involves directly embedding the SVG code into your React component. Here's an example:
function Logo() {
return (
<svg width="50" height="50">
<circle cx="25" cy="25" r="25" fill="purple" />
</svg>
);
}
In this code snippet, we're creating a purple circle. CX and CY determine the x and y coordinates of the circle's center, respectively, while R specifies the radius of the circle. The fill attribute sets the color of the circle.
SVG as an Image Source
The second method involves using the SVG file as a source for an image element. Here's how you can do it:
import React from 'react';
import logo from './logo.svg';
function App() {
return (
<div>
<img src={logo} alt="Logo" />
</div>
);
}
export default App;
In this example, we're importing an SVG file and using it as the source for an img element. This method is more straightforward and doesn't require you to write any SVG code.
Conclusion
And there you have it! In this article, we've learned how to use .ai files in ReactJS by converting them into SVG files. We've also looked at two ways to use SVGs in ReactJS: inline SVG and SVG as an image source.
It might sound like a lot of work, but remember, it's like learning how to ride a bike. It might seem tricky at first, but once you get the hang of it, it becomes second nature.
So the next time you're handed a .ai file, don't panic. Just remember the steps we've covered here, take it one step at a time, and you'll be incorporating beautiful, scalable graphics into your ReactJS applications in no time. Happy coding!
|
__label__pos
| 0.988815 |
PercentageCalculator .pro Discount Percentage Fraction to % Decimal to %
22.5 percent of 90?
Percentage Calculator
What is % of
Answer:
Percentage Calculator 2
is what percent of ?
Answer: %
Percentage Calculator 3
is % of what?
Answer:
Solution for 'What is 22.5% of 90?'
In all the following examples consider that:
Solution Steps
The following question is of the type "How much X percent of W", where W is the whole amount and X is the percentage figure or rate".
Let's say that you need to find 22.5 percent of 90. What are the steps?
Step 1: first determine the value of the whole amount. We assume that the whole amount is 90.
Step 2: determine the percentage, which is 22.5.
Step 3: Convert the percentage 22.5% to its decimal form by dividing 22.5 into 100 to get the decimal number 0.225:
22.5100 = 0.225
Notice that dividing into 100 is the same as moving the decimal point two places to the left.
22.5 → 2.25 → 0.23
Step 4: Finally, find the portion by multiplying the decimal form, found in the previous step, by the whole amount:
0.225 x 90 = 20.25 (answer).
The steps above are expressed by the formula:
P = W × X%100
This formula says that:
"To find the portion or the part from the whole amount, multiply the whole by the percentage, then divide the result by 100".
The symbol % means the percentage expressed in a fraction or multiple of one hundred.
Replacing these values in the formula, we get:
P = 90 × 22.5100 = 90 × 0.225 = 20.25 (answer)
Therefore, the answer is 20.25 is 22.5 percent of 90.
Solution for '22.5 is what percent of 90?'
The following question is of the type "P is what percent of W,” where W is the whole amount and P is the portion amount".
The following problem is of the type "calculating the percentage from a whole knowing the part".
Solution Steps
As in the previous example, here are the step-by-step solution:
Step 1: first determine the value of the whole amount. We assume that it is 90.
(notice that this corresponds to 100%).
Step 2: Remember that we are looking for the percentage 'percentage'.
To solve this question, use the following formula:
X% = 100 × PW
This formula says that:
"To find the percentage from the whole, knowing the part, divide the part by the whole then multiply the result by 100".
This formula is the same as the previous one shown in a different way in order to have percent (%) at left.
Step 3: replacing the values into the formula, we get:
X% = 100 × 22.590
X% = 225090
X% = 25.00 (answer)
So, the answer is 22.5 is 25.00 percent of 90
Solution for '90 is 22.5 percent of what?'
The following problem is of the type "calculating the whole knowing the part and the percentage".
Solution Steps:
Step 1: first determine the value of the part. We assume that the part is 90.
Step 2: identify the percent, which is 22.5.
Step 3: use the formula below:
W = 100 × PX%
This formula says that:
"To find the whole, divide the part by the percentage then multiply the result by 100".
This formula is the same as the above rearranged to show the whole at left.
Step 4: plug the values into the formula to get:
W = 100 × 9022.5
W = 100 × 4
W = 400 (answer)
The answer, in plain words, is: 90 is 22.5% of 400.
Sample percentage problems
|
__label__pos
| 0.999093 |
menu
menu
キーワード検索
前月(9月)の人気記事トップ10
1. ( 1－) 【CSS Tips】CSSだけでドロップダウンメニュー
2. ( 2－) 【CSS Tips】CSSだけでサイズ可変・スマホ対応のアコーディオン
3. ( 3－) 【HTML5】スマホサイトの作成・基本編
4. ( 4－) 【CSS Tips】CSSだけでブロック要素の表示非表示(トグルボタン)
5. ( 7↑) 【jQuery】表示しているブラウザの高さを取得してCSSのheightに指定
6. ( 5↓) 【jQuery入門】jQueryで日時を表示
7. (10↑) 【HTML5】HTML5・ページ作成の基本
8. ( 9↑) 【MySQL】Windows 10にMySQLをインストール
9. ( 8↓) 【Mac Tips】MacにInkscapeをインストール
10. ( 6↓) 【CSS Tips】スマホサイト向け横にスクロールするナビゲーション
【スクロール】ヘッダーをトップに固定してスクロールでアニメーション
• Labs
jQuery
こんにちは（・∀・）
今回はjQueryでヘッダーをトップに固定するスティッキーヘッダーと、スクロールするとそのヘッダーがCSSのアニメーションで拡大縮小するサンプルをご紹介します。
レスポンシブデザインに対応してます。
サンプル
HTML
jQueryを使用するのでHTMLの<head>内にjQuery 1.x snippetを読み込みます。
Google Hosted Libraries
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
<header>
<p><img src="logo.png" alt="Webデザインラボ"></p>
</header>
CSS
header {
position: absolute;
background: #ccc;
top: 0;
width: 100%;
height: 60px;
border-bottom: none;
box-shadow: 0 1px 2px #aaa;
}
header #toplogo {
margin-top: 0;
}
@keyframes anim1 {
0% { height: 60px; }
100% { height: 40px; }
}
@keyframes anim2 {
0% { height: 40px; }
100% { height: 60px; }
}
@keyframes anim3 {
0% { width: 200px; height: 40px; }
100% { width: 100px; height: 20px; }
}
@keyframes anim4 {
0% { width: 100px; height: 20px; }
100% { width: 200px; height: 40px; }
}
.fixed {
position: fixed;
height: 40px;
animation: 0.5s forwards anim1;
text-align: center;
}
.fixed2 {
position: fixed;
height: 60px;
animation: 0.2s backwards anim2;
text-align: center;
}
.fixed section h2 img {
width: 100px;
height: 20px;
animation: 0.5s forwards anim3;
}
.fixed2 section h2 img {
width: 200px;
height: 40px;
animation: 0.2s backwards anim4;
}
.sample-demo {
margin: 0;
padding: 0;
}
h3 {
margin-top: 60px;
margin-bottom: 10px;
}
.container {
position: relative;
overflow: hidden;
font-size: 28px;
color: #333;
box-sizing: border-box;
}
.container .box1 {
position: relative;
min-height: 100vh;
box-sizing: border-box;
text-align: left;
padding: 10px;
background: #fff;
}
Result
サンプルデモはこちら
関連リンク
【スクロール】スクロールしても要素が固定するスティッキーサイドバー
【スクロール】グローバルナビをトップに固定するスティッキーナビ+ドロップダウンメニュー
【スクロール】グローバルナビをトップに固定するスティッキーナビ
• カテゴリー：Labs
|
__label__pos
| 0.752717 |
dcsimg
May 23, 2015
Hot Topics:
Communicating over Sockets: Blocking vs. Unblocking
• March 27, 2006
• By Mark Strawmyer
• Send Email »
• More Articles »
Sample Socket Connection Pool
You know the 3rd party system allows socket connections to remain open. In an effort to optimize performance, it is desired to have a connection pool of sockets open to the 3rd party system similar in concept to a database connection pool. The trailing sample code will provide you with a simple connection pooling object for your use. It will handle open and closing connections appropriately.
Sample Client Connection Pool Class
Thanks to the release of .NET 2.0, creating a socket connection pool isn't as difficult as it would have been in the past. Generics have introduced much of the plumbing that is required to accomplish the task through the System.Collections.Generic.Queue<T> object. You'll treat your socket connection pool as if it is a queue where you get connections from the queue and put connections back into the queue when you're complete.
using System;using System.Collections.Generic;using System.Net;using System.Net.Sockets;namespace CodeGuru.SocketSample{ /// <summary> /// Connection pool of sockets. /// </summary> public static class SocketConnectionPool { /// <summary>The maximum size of the connection pool.</summary> private static readonly int POOL_SIZE = 20; /// <summary>The default port number for the /// connection.</summary> private static readonly int DEFAULT_PORT = 8080; /// <summary>Queue of available socket connections.</summary> private static Queue<Socket> availableSockets = new Queue<Socket>(); /// <summary> /// Get an open socket from the connection pool. /// </summary> /// <returns>Socket returned from the pool or new socket /// opened.</returns> public static Socket GetSocket() { if (SocketConnectionPool.availableSockets.Count > 0) { Socket socket = null; while( SocketConnectionPool.availableSockets.Count > 0 ) { socket = SocketConnectionPool.availableSockets.Dequeue(); if (socket.Connected) { return socket; } } } return SocketConnectionPool.OpenSocket(); } /// <summary> /// Return the given socket back to the socket pool. /// </summary> /// <param name="socket">Socket connection to return.</param> public static void PutSocket(Socket socket) { if (SocketConnectionPool.availableSockets.Count < SocketConnectionPool.POOL_SIZE) { if (socket != null) { if (socket.Connected) { // Set the socket back to blocking and enqueue socket.Blocking = true; SocketConnectionPool.availableSockets.Enqueue(socket); } } } else { // Number of sockets is above the pool size, so just // close it. socket.Close(); } } /// <summary> /// Open a new socket connection. /// </summary> /// <returns>Newly opened socket connection.</returns> private static Socket OpenSocket() { IPHostEntry localMachineInfo = Dns.GetHostEntry("127.0.0.1"); IPHostEntry remoteMachineInfo = Dns.GetHostEntry("127.0.0.1"); IPEndPoint serverEndpoint = new IPEndPoint( remoteMachineInfo.AddressList[0], SocketConnectionPool.DEFAULT_PORT); IPEndPoint myEndpoint = new IPEndPoint( localMachineInfo.AddressList[0], 0); Socket socket = new Socket( myEndpoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp); socket.Connect(serverEndpoint); return socket; } }}
Blocking vs. Unblocking
Now that you have your sample server and connection pool, you can create your client. A common stumbling block working with sockets and the main point of this article is blocking vs. unblocking sockets. Many examples demonstrate the use of blocking sockets, but don't really describe the behavior as blocking; this causes confusion. Blocking is where the receiving party blocks all activity while it waits to receive input from the socket. Sounds logical enough, but there are issues when the sending party is sending variant output and the receiver doesn't know all information has been sent.
Blocking Socket Sample
The following sample demonstrates the use of blocking sockets. You have to create a byte array of a specified length to read in the input. The byte array is a fixed size, so it may take multiple reads to read all of the input back from the socket connection. Thus, you do the Receive() method in a loop until all of the input is read from the socket. Here is some example code to illustrate the point.
Socket socket = null;try{ // Send the request socket = SocketConnectionPool.GetSocket(); socket.Send(System.Text.Encoding.ASCII.GetBytes("<uptime></uptime>")); // Read the response on a non-blocking socket System.Text.StringBuilder output = new System.Text.StringBuilder(); byte[] buffer = new byte[256]; int bytesRead = 0; string bufferString = ""; do { bytesRead = socket.Receive(buffer, buffer.Length, 0); bufferString = System.Text.Encoding.ASCII.GetString(buffer); output.Append(bufferString); } while (bytesRead > 0); // Display the response Console.WriteLine("Output: " + output.ToString());}finally{ SocketConnectionPool.PutSocket(socket);}
If you run this example, you will proceed through the loop a number of times based on the size of the output you are returning from the sample server. With the sample provided, it should only take a single read. However, the loop will try a second read and get stuck on the Receive method. That occurs because the server has stopped sending bytes, but the client is blocking and doesn't have any way to know the server is actually done sending. You could set the timeout on the client connection to a low interval, but that is not ideal in case the request takes a bit to respond. The server could be made to close the connection to indicate when it is done, but in this sample the server is a 3rd party and outside your control.
Unblocking Socket Sample
The following sample code demonstrates the use of a nonblocking socket. It gets around the prior issue where the client ends up in an indefinite state of waiting on a response. The key difference is in the Receive method. The nonblocking version will return immediately from the receive call, whereas the prior version would wait indefinitely for output. The nonblocking call to Receive will read whatever is available on the socket at that point in time. Thus, you'll read a little bit differently. You'll read in an infinite loop until the desired end tag is located from the XML. If something happens along the way, such as the server shutting down, the read will error out anyway and break the loop.
Socket socket = null;try{ // Send the request socket = SocketConnectionPool.GetSocket(); socket.Send(System.Text.Encoding.ASCII.GetBytes("<uptime></uptime>")); // Read the response on a non-blocking socket System.Text.StringBuilder output = new System.Text.StringBuilder(); string bufferString = ""; socket.Blocking = false; while (true) { if (socket.Poll(1000, SelectMode.SelectRead)) { byte[] buffer = new byte[socket.Available]; socket.Receive(buffer, SocketFlags.None); bufferString = System.Text.Encoding.ASCII.GetString(buffer); output.Append(bufferString); } // Check if we've received the entire response if (bufferString.IndexOf("</uptime>") != -1) break; } // Display the response Console.WriteLine("Output: " + output.ToString());}finally{ SocketConnectionPool.PutSocket(socket);}
Other Considerations
There is additional functionality that could be added to this approach to make it more usable. An object model could be developed. You could establish a base class from which all business methods will inherit. A communicator class can be created to accept types based on the base business method class. The communicator could serialize the objects down to XML, send the XML across to the 3rd party system, read the XML response back from the 3rd party, and deserialize back into objects. That would simplify the process of sending requests and allow for additional business methods to be added at will.
Future Columns
The next column has yet to be determined. If you have something in particular that you would like to see explained, please e-mail me at [email protected].
About the Author
Mark Strawmyer, MCSD, MCSE, MCDBA is a Senior Architect of .NET applications for large and mid-size organizations. Mark is a technology leader with Crowe Chizek in Indianapolis, Indiana. He specializes in architecture, design, and development of Microsoft-based solutions. Mark was honored to be named a Microsoft MVP for application development with C# for the third year in a row. You can reach Mark at [email protected].
Page 2 of 2
Comment and Contribute
(Maximum characters: 1200). You have characters left.
Enterprise Development Update
Don't miss an article. Subscribe to our newsletter below.
Sitemap | Contact Us
Thanks for your registration, follow us on our social networks to keep up-to-date
Rocket Fuel
|
__label__pos
| 0.740514 |
Jump to content
Recommended Posts
Hi,
I have setup Windows 7 (64-bit) with ESET 4 and Malwarebytes Pro (v 1.60.xx onwards). In order to delay the MBAM Service by 20 secs (to avoid potential conflict with ESET at start-up) I do the following:
1. Change the start-up type for service "mbamservice.exe" to Automatic, from Automatic (Delayed Start).
2. Add a new DWORD Value "delayguistart" and set it to 20 at the Registry key:
HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Malwarebytes' Anti-Malware
This works great, however, I notice that the MBAM service can revert back to Automatic (Delayed Start). This leads to a much longer start-up (1-2 mins) and hence a delay in protection when online.
I have just isolated one thing that causes this change of the start-up type (back to delayed start). If I start the scanner and click onto the “scheduler settings” tab, without doing any changes even, I notice that the service is reset to delayed start. Why does this happen?
Secondly, I believe that updating the program version may also change the MBAM Service start-up back to delayed start. Can you confirm this? I isolate this by turning off the “program update” options within the “updater settings” tab.
Finally, I think I have noticed it change without the above 2 steps occurring. Are you aware of the regular identity updates triggering this action? Are you aware of anything else doing it?
It would be great if the user-chosen start-up type was never reset by the program. This would allow the program to start protecting the PC at the desired, shorter delay time and not after 1-2 mins.
Thanks in advance
Mike
Link to post
Share on other sites
1) I belive the delay is set to avoid the boot time scan that most decent AV's run and on Eset and Avast that can be in the first 1-2 minutes of starting.
2) The Malwarebytes system starts earlier than you may think, the GUI is certainly the last thing to be loaded.
Link to post
Share on other sites
Hello and :welcome:
If I do recall correctly, changing the service to automatic and then going into the scheduler does change it back. They are aware of that. That being said, you should probably leave it at delayed startup as that allows you ESET to start up first. You should not need the reg key. If you are having issues with them playing together, perhaps you should enter exceptions in your ESET av as outlined below.
For an example on how to setup exceptions in ESET Smart Security please see this guide that orubio provided right HERE.
Link to post
Share on other sites
Just FYI, we are considering changing the default startup behavior of MBAMService on Vista and Windows 7 to remove the delayed startup as we've been doing ongoing testing with a wide array of antivirus products and have eliminated nearly every incompatibility that we're aware of and are still working on any that remain, both on our end, and by working with the AV vendors themselves to get the issues resolved.
Link to post
Share on other sites
Hi Samuel,
Thanks for the update regarding the possibility of removing the delayed start. I've worked with ESET (and MB) for years and know there's no conflict with a 20 second delay (via the Registry DWORD). Can you not simply include an 'advanced' option (that I can enable) that prevents the resetting of the service to delayed start mode? Or, can you provide an option to enter a user-defined time delay?
Can you confirm whether a program update and/or identity update reset the service start-up mode, as asked in my original post? Thanks.
Cheers
Mike
Link to post
Share on other sites
Can you not simply include an 'advanced' option (that I can enable) that prevents the resetting of the service to delayed start mode?
We have something better in mind (see below).
Or, can you provide an option to enter a user-defined time delay?
That's the plan. We have decided that in a future release (though I don't know when yet), that we will be adding the 'delayguistart' function to the user interface so that it can still be delayed by the user if desired.
Can you confirm whether a program update and/or identity update reset the service start-up mode, as asked in my original post?
Yes on both counts. Accessing the scheduler causes it to revert to a delayed start because whenever the scheduler is accessed, one of the things it does is make certain that MBAMService is installed and set to launch automatically (with our default delay of course) because it must be running for the scheduler to function. Updating the program also resets it for the same reason, because it reinstalls the service, which sets it to its default startup type (delayed in this case) because it is required for both the scheduler and the protection module.
I hope that helps to clear things up a bit, please let us know if you have any further questions or issues.
Thanks :)
Link to post
Share on other sites
Hi Samuel,
Thanks for the quick response.
Just to make sure I'm 100% here, as it stands it is NOT possible to keep the service on an Automatic (only) start-up, since the first daily (or hourly) identity update will simply reset the service to Automatic (Delayed Start), even with NO program updating enabled? Is this correct?
I don't quite understand the logic whereby accessing the scheduler automatically resets the start-up method to "delayed start". If the service is set-up to start Automatically (NO Delayed start) and is hopefully running, why can't the scheduler see that the MBAM service is running and therefore avoid the need to reset the start up mode? I can understand it resetting the service start-up mode IF the service had NOT started. I guess there's more to it than I understand?
I'm glad you're looking into incorporating the "delayguistart" function. Is this update likely in the coming months?
Mike
Link to post
Share on other sites
Just to make sure I'm 100% here, as it stands it is NOT possible to keep the service on an Automatic (only) start-up, since the first daily (or hourly) identity update will simply reset the service to Automatic (Delayed Start), even with NO program updating enabled? Is this correct?
No, database updates (scheduled or otherwise) do not affect the service startup type, so it won't be reset by that. Only accessing the scheduler (i.e. visiting the Scheduler Settings tab under settings or clicking the Scheduler button on the Protection tab) or installing a new program version (not database version) will reset the startup type to delayed.
I don't quite understand the logic whereby accessing the scheduler automatically resets the start-up method to "delayed start". If the service is set-up to start Automatically (NO Delayed start) and is hopefully running, why can't the scheduler see that the MBAM service is running and therefore avoid the need to reset the start up mode?
It's because it doesn't check, it simply makes sure that it will be running by resetting it (i.e. if the service were missing/broken for some reason, it would be reset so that it is functional as normal again).
I'm glad you're looking into incorporating the "delayguistart" function. Is this update likely in the coming months?
As I said, I'm not sure when it will be, but currently the plan is to eliminate starting the service with a delay (setting it to Automatic instead of Automatic (Delayed Start) and adding that function to the user interface in case it is needed. When that will happen or in what version is still unknown at this point.
Link to post
Share on other sites
Create an account or sign in to comment
You need to be a member in order to leave a comment
Create an account
Sign up for a new account in our community. It's easy!
Register a new account
Sign in
Already have an account? Sign in here.
Sign In Now
• Recently Browsing 0 members
• No registered users viewing this page.
Back to top
×
×
• Create New...
Important Information
This site uses cookies - We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.
|
__label__pos
| 0.617989 |
US8171462B2 - User declarative language for formatted data processing - Google Patents
User declarative language for formatted data processing Download PDF
Info
Publication number
US8171462B2
US8171462B2 US11408843 US40884306A US8171462B2 US 8171462 B2 US8171462 B2 US 8171462B2 US 11408843 US11408843 US 11408843 US 40884306 A US40884306 A US 40884306A US 8171462 B2 US8171462 B2 US 8171462B2
Authority
US
Grant status
Grant
Patent type
Prior art keywords
string
metadata
constraints
constraint
anchor
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active, expires
Application number
US11408843
Other versions
US20070250811A1 (en )
Inventor
David Ahs
Jordi Mola Marti
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Microsoft Technology Licensing LLC
Original Assignee
Microsoft Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Grant date
Links
Images
Classifications
• GPHYSICS
• G06COMPUTING; CALCULATING; COUNTING
• G06FELECTRIC DIGITAL DATA PROCESSING
• G06F8/00Arrangements for software engineering
• G06F8/40Transformation of program code
• G06F8/41Compilation
Abstract
A user declarative language for formatted data processing is provided. The user declarative language may be used to generate constraints which can be projected onto a string according to one or more anchor points. The constraints can correspond to evaluation criteria. At least a portion of a string can be evaluated according to the evaluation criteria.
Description
BACKGROUND
Generally described, localizing resources for computer systems during software development involves transforming source data corresponding to one market into target data corresponding to a different market. For example, localization can involve translating source data in one language into target data in another language. Localization can also involve transforming data between markets in the same language, such as transforming source data corresponding to Japanese for children into target data corresponding to Japanese for adults. A resource is generally defined as an item of data or code that can be used by more than one program or in more than one place in a program, such as a dialog box. One example of a resource is an error message string used to alert a computer user of an error condition. Additionally, the error message can contain one or more placeholders to be replaced with the value of the placeholder before the message is displayed.
Various assumptions can be associated with a resource. For example, the author of an error message such as “File <PH> not found”, where “<PH>” is an example of a placeholder to be replaced with the name of a file, may assume that the file name will be provided at a later time and that the reader of the message understands the meaning of the term “file.” To use the error message in various markets, it may need to be translated into several languages. In a typical development environment, a word-for-word translation may be used to localize a resource. However, the resulting translation may not capture contextual data associated with the resource. For example, a word in a resource, such as the word “file”, can have more than one meaning and thus the context in which the word is used is needed to generate a correct translation. Additionally, functional items, such as placeholders, need to provide functionality in target data that corresponds to the functionality provided in source data. For example, the “<PH>” in the example error message needs to function such that it is replaced with the name of a file in any transformation of the error message.
One approach to capturing contextual and functional information during localization involves comparing each individual assumption associated with the source resource against the target resource to ensure that the target resource complies with every assumption. For example, one assumption associated with a source resource can be that invalid characters are ‘*’ and ‘\’. An additional assumption associated with the same resource can be that invalid characters are ‘%’ and ‘\’. To validate the target resource using these assumptions, a validation engine could first check that the target string does not contain either ‘*’ or ‘\’. Next, the validation engine could check that the target string does not contain ‘%’ and ‘\’. However, checking each individual assumption is not efficient. Further, individual assumptions may be incompatible with other individual assumptions or may be redundant.
Pseudo-localization of a resource can be used to ensure that assumptions are correctly captured so that they can be preserved in a target. The process of pseudo-localization typically involves generating a random pseudo-translation of a source string. The pseudo-translation can then be tested, in a process generally known as validation, to ensure that assumptions from the source string are preserved in the pseudo-translation. However, typical tools that perform pseudo-localization of a source string for testing purposes do not use the same validation techniques as tools used to validate target translations. Thus, localized software is not tested as thoroughly as would be possible if pseudo-localized resources were able to be validated in the same manner.
SUMMARY
This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This summary is not intended to identify key features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.
Generally described, the present invention is directed toward systems and methods for processing and validating formatted data. More specifically, a user declarative language may be used to generate constraints which can be projected onto a string according to one or more anchor points.
In accordance with one aspect, a computer-readable medium having computer-executable components for processing source data is provided. The components include a rule component operable to generate one or more constraints and one or more anchor points. The one or more constraints can correspond to evaluation criteria and can be projected onto a target string using the one or more anchor points.
In accordance with another aspect, a computer-readable medium having computer-executable components for processing source data is provided. The components include a rule component operable to obtain at least one parameter and to generate one or more constraints and one or more anchor points. The one or more anchor points can be used to project the one or more constraints onto a target string.
In accordance with another aspect, a method for converting a regular expression into metadata is provided. A source string can be obtained, possibly from a user interface or data store. The regular expression can be parsed. Metadata can be obtained by matching the regular expression against the source string. The metadata can correspond to one or more constraints and one or more anchor points. The one or more anchor points can be used to project the one or more constraints onto a string.
DESCRIPTION OF THE DRAWINGS
The foregoing aspects and many of the attendant advantages of this invention will become more readily appreciated as the same become better understood by reference to the following detailed description, when taken in conjunction with the accompanying drawings, wherein:
FIG. 1 is a block diagram of an illustrative operating environment including a metadata compiler, a metadata optimizer and arbitrator, and a number of processing components in accordance with an aspect of the present invention;
FIG. 2 is a block diagram of the operating environment of FIG. 1 illustrating a number of metadata compilers, a metadata optimizer and arbitrator, and a number of processing components in accordance with an aspect of the present invention;
FIG. 3 is a block diagram of the operating environment of FIG. 1 illustrating the processing and validation of metadata by an authoring user interface, a number of metadata compilers, a metadata optimizer and arbitrator, a projection component, and a validation component in accordance with an aspect of the present invention;
FIG. 4 is a block diagram of the operating environment of FIG. 1 illustrating the localization of strings via an authoring user interface, a number of metadata compilers, a metadata optimizer and arbitrator, a translation user interface, and a number of processing components in accordance with an aspect of the present invention;
FIGS. 5A-5D are block diagrams depicting the placing of constraints against various strings according to corresponding anchor points in accordance with an aspect of the present invention;
FIG. 6 is a flow diagram illustrating a source-data processing routine implemented by the operating environment of FIG. 3 in accordance with an aspect of the present invention;
FIG. 7 is a flow diagram illustrating a target-data processing routine implemented by the operating environment of FIG. 4 in accordance with an aspect of the present invention;
FIG. 8 is a flow diagram illustrating a normalization sub-routine implemented by a metadata optimizer and arbitrator in accordance with an aspect of the present invention;
FIG. 9 is a block diagram depicting the resource-neutralization, translation, and resource-injection of two resources in accordance with an aspect of the present invention;
FIG. 10 is a flow diagram illustrating a fuzzying routine for generating test data in accordance with an aspect of the present invention;
FIG. 11 is a flow diagram illustrating a regular-expression conversion routine implemented by a metadata compiler in accordance with an aspect of the present invention;
FIG. 12 is a block diagram of a user interface including a comment display portion, an input string display portion, a suggested values display portion, and a translation display portion in accordance with an aspect of the present invention; and
FIGS. 13-15 are block diagrams of a user interface including a source-string display portion, a target string display portion, a source metadata display portion, and a target metadata display portion formed in accordance with an aspect of the present invention.
DETAILED DESCRIPTION
Generally described, the present invention is directed toward systems and methods for processing and validating formatted data. More specifically, in accordance with the present invention, source data is compiled into metadata including one or more constraints and one or more corresponding anchor points. The one or more constraints correspond to evaluation criteria which can be used to validate a localized version of a string. Various processing components can consume the compiled metadata. For example, metadata can be projected onto a string, used to validate a string, used to assist in translation of a string, used to correct a string, and used to display a marked string. Although the present invention will be described with relation to illustrative user interfaces and operating environments, one skilled in the relevant art will appreciate that the disclosed embodiments are illustrative in nature and should not be construed as limiting.
With reference now to FIG. 1, an illustrative operating environment 100 includes a metadata compiler 104 and a metadata optimizer and arbitrator 106 operable to generate normalized metadata for consumption by various processing and translation components. The metadata compiler 104 is operable to compile source data 102 into metadata. In an illustrative embodiment, source data 102 can include a source string. For example, source data 102 can include the following string: “This is a string.” Further, source data 102 can include a rule. For example, the source data 102 could include the following rule: “{MaxLen=25}”. Rules will be described in greater detail below. Source data 102 can further include resource information. Resource information can be used to specify attributes of a resource, such as the corresponding platform, the corresponding usage of the resource and the corresponding language of the resource. For example, resource information can be used to specify a particular platform that corresponds to a source or target string. Additionally, the metadata compiler 104 can infer restrictions by analyzing source data 102. For example, a compiler component 104 can infer a placeholder by parsing a source string. Alternatively, a placeholder in a source string can be inferred based on corresponding resource information.
In an illustrative embodiment, compiled metadata generated by a metadata compiler 104 can include one or more constraints which correspond to evaluation criteria and one or more anchor points for mapping the one or more constraints to a string. The metadata optimizer and arbitrator 106 obtains compiled metadata and generates normalized metadata using the compiled metadata. The normalization process will be discussed in more detail below. In an illustrative embodiment, both the compiled metadata and the normalized metadata can correspond to abstract metadata. Abstract metadata corresponds to metadata that has not yet been placed against a string. Once metadata has been compiled and normalized, the metadata can be used by one or more processing components in the operating environment 100. The processing components generally consume the metadata and can perform additional tasks. A first set of processing components 108, 110, 112, and 114 can be used to manipulate a string and/or corresponding metadata while a second set of processing components 116, 118, 120, and 122 can be used to translate a string.
Within the first set of processing components, a projection component 110 can utilize the metadata to project the one or more constraints onto a string according to the corresponding anchor points. Additionally, a validation component 108 can utilize metadata to validate a string against the one or more constraints included in the metadata. Validating a string involves evaluating the criteria associated with the constraints that correspond to the string. If the criteria corresponding to a constraint are satisfied, then the constraint evaluates to “true”. Conversely, if the criteria corresponding to a constraint are not satisfied, then the constraint evaluates to “false”. In an alternative embodiment, constraints evaluate to a severity level. For example, constraints may evaluate to a warning or an error. A correction component 112 can utilize metadata to modify a string such that the corresponding constraints included in the metadata are satisfied. Additionally, a display component 114 can display a string that has been marked according to corresponding metadata.
The illustrative operating environment 100 can also include a plurality of processing components operable to translate a string based on the compiled metadata. In an illustrative embodiment, the translation components can translate all or portions of a string as dictated by the metadata. Alternatively, a translation component can generate a suggested translation which violates one or more of the constraints included in the metadata. In such a case, portions of the suggested translation which violate the constraints can be marked. Marking suggested translations in this manner can signal to a user the portions of the suggested translation which need to be modified for the constraints to be satisfied. Marking will be discussed in more detail below. For example, the metadata can include one or more constraints that lock one or more portions of the string and that prevent those portions from being translated. In another example, the metadata can include a set of constraints that prevents a corresponding placeholder in a string from being translated. A translation component can also retrieve translations from a data store and cause the translations to be marked according to corresponding metadata. With continued reference to FIG. 1, the operating environment 100 can include an auto-translation component 116 operable to translate a string in accordance with corresponding metadata. As will be appreciated by one skilled in the art, auto-translation involves matching a string with a database of strings that includes corresponding translations. Further, the operating environment 100 can include a machine-translation component 118 that can translate a string in accordance with corresponding metadata. As will be appreciated by one skilled in the art, machine translation involves the use of computer hardware or software to translate text from one language into another. Still further, the operating environment 100 can include a manual translation component 120 that can translate a string in accordance with corresponding metadata. As will be appreciated by one skilled in the art, manual translation typically involves the use of a human to translate from one language into another. Even further, the operating environment 100 can include a pseudo-localization component 122 that can be used to provide a pseudo-translation of the string to be used for testing purposes. Pseudo-localization will be described in greater detail below. Although the illustrative operating environment 100 is illustrated with all of the above processing components, one skilled in the relevant art will appreciate that the operating environment 100 can vary the number of processing components. In an illustrative embodiment, metadata can be consumed in a manner that is agnostic to workflow.
In an illustrative embodiment, compiled metadata can be utilized to preserve the intent, context, and format of a communication while allowing for actual data in the transaction to be converted as appropriate to a corresponding market or locale. For example, metadata can be utilized to preserve the assumptions associated with a source string after the string has been translated. In one aspect, the constraints generated by a compiler 104 are declarative and thus describe what the corresponding restriction or assumption is, but does not describe how to fulfill it. Because the constraints are declarative, consumption of the constraints is more flexible. In an illustrative embodiment, constraints can be combined through anchoring to build more “complex” constraints.
In another aspect, constraints are categorized. In an illustrative embodiment, constraints can be categorized according to a severity level. For example, a constraint that is not satisfied can issue an error or a warning. In another embodiment, a constraint can be categorized according to whether the constraint operates on code points or characters. For example, functional constraints can operate on code points whereas terminology constraints can operate on characters. Specifically, a string representing the term “file” may be associated with a hotkey such that on a functional level the string appears as “fil&e”. A terminology constraint can operate on the characters in the string “file” and would thus not see the “&” while a functional constraint can operate on code points and would be able to detect the “&”. Furthermore, a constraint can be categorized according to whether it is positive or negative. For example, a positive constraint can specify how a corresponding portion of a string should appear whereas a negative constraint can specify how a corresponding portion of a string should not appear. Still further, a constraint can be categorized according to whether the constraint checks counts, elements, or sequences. For example, a count constraint can limit the length of a string or substring. A constraint that checks elements can validate based on the value of the corresponding elements. Elements can correspond to characters or code points. Additionally, constraints can be case-sensitive or case-insensitive. Likewise, constraints can be culture-sensitive or culture-insensitive. Constraints can also be regular expressions. A constraint that checks sequences can validate based on the value of the corresponding sequence, such as a substring. In a further aspect, constraints are instance agnostic. For example, a constraint on a string corresponding to the English language will validate in the same manner as a constraint on a string corresponding to the Spanish language. Alternatively, constraints can be language-specific. In a further aspect, constraints can be projected onto a string instance. Dependencies can also exist between constraints, such that, for example, the result of the evaluation of one constraint would correspond with the result of the evaluation of another constraint.
With reference now to FIG. 2, the illustrative operating environment 100 of FIG. 1 can include a plurality of metadata compilers 104 operable to compile source data into metadata. In an illustrative embodiment, the plurality of metadata compilers 104 operate in parallel, such that source data 102 from several sources can be compiled into metadata. The metadata compilers 104 may also operate in series such that each compiler 104 performs a different compilation function. Further, in an illustrative embodiment, several different metadata compiler 104 versions may be operable in the illustrative operating environment 100. For example, a user responsible for entering source data may grow accustomed to the interface corresponding to a version 1.0 metadata compiler. That user can continue to use the version 1.0 compiler even as a version 2.0 compiler comes on line for use by others. As illustrated in FIG. 2, the metadata optimizer and arbitrator 106 can obtain compiled metadata from each of the metadata compilers 104 and normalize the metadata. Normalization can involve consolidating redundant constraints and resolving incompatibilities amongst constraints such that the processing components 108, 110, 112, 114, 116, 118, 120, and 122 receive a consistent set of metadata. The normalization process will be discussed in more detail below.
With reference now to FIG. 3, the interaction by various components of the operating environment 100 to process and validate metadata will be described. In an illustrative embodiment, an authoring user interface 302 can obtain user input for compilation by one or more metadata compilers 104. The user input can correspond to source data 102 and can include one or more processing attributes. As discussed above, the one or more metadata compilers 104 obtains the user input as source data and compiles the user input into metadata. User input can be directed to any one or more of the metadata compilers 104. For example, a metadata compiler 104 can accept specific types of source data 102, such as source data that includes only a source string or source data that includes a source string and a rule. Further, by examining user input, a metadata compiler 104 can infer additional constraints.
Still with reference to FIG. 3, in an illustrative embodiment, the metadata optimizer and arbitrator 106 obtains abstract metadata and generates normalized abstract metadata. As will be described in greater detail below, the metadata optimizer and arbitrator 106 filters the metadata from the one or more compilers 104 to remove redundant constraints and/or incompatible constraints. A projection component 110 obtains abstract metadata and projects the metadata onto a target string. As discussed above, in an illustrative embodiment, the metadata includes one or more constraints which correspond to evaluation criteria and one or more anchor points mappable to a target string. Projecting metadata involves placing the one or more constraints on top of a target string according to the corresponding anchor points. For purposes of verification, the target string can be the source string.
A validation component 108 obtains projected metadata and validates the string against the one or more constraints. In an alternative embodiment, the validation component 108 can validate a string against abstract metadata. Validating a string against metadata involves determining whether the string satisfies the evaluation criteria corresponding to the constraints included in the metadata. In an illustrative embodiment, a string fails to validate if any corresponding evaluation criterion is not satisfied. In an alternative embodiment a string fails to validate if any corresponding evaluation criterion is not satisfied and results in the generation of an error. For example, some failed evaluation criteria can result in the generation of a warning, which may not prevent the string from validating. An authoring user interface 302 can obtain results of the validation process from the validation component 108 and display the validated string to a user. In an illustrative embodiment, the string is marked according to the corresponding constraints. For example, the string can be marked to show the user which portions of the string satisfy the constraints and which portions fail to satisfy the constraints. Further, the string can be marked to alert the user of the location of errors. For example, syntax errors in the source string can be marked. In an illustrative embodiment, the string may be auto-corrected so that it satisfies the corresponding constraints. In an alternative embodiment, suggested modifications may be displayed to a user for selection. The process of marking and displaying a string will be discussed in more detail below.
With reference now to FIG. 4, the interaction of various components of the operating environment 100 to localize a string will be described. In an illustrative embodiment, an authoring user interface 302 can obtain user input for compilation by one or more metadata compilers 104. A metadata optimizer and arbitrator 106 obtains abstract metadata from the one or more metadata compilers 104 and generates normalized, abstract metadata as described above. A projection component 110 obtains abstract metadata and user input including a target string from a translation user interface 402 and projects the metadata onto the target string. In an illustrative embodiment, the target string is a string a user desires to validate and translate. A validation component 108 validates the target string against the projected metadata. In an alternative embodiment, the validation component 108 can obtain abstract metadata and a target string and validate the target string using the abstract metadata. Further, the validation component 108 can examine a source string and a corresponding target string and check that the same set of guarantees are present on both strings.
Translation component 404 obtains the results of the validation process and translates the validated target string. A correction component 112 can obtain translated results and can modify the translation such that it satisfies the associated metadata. Further, a translation user interface 402 can obtain the corrected results and display the corrected translation to a user. The translation user interface 402 can display a string using associated metadata to mark portions of the string. Marking a string for display to a user will be discussed in more detail below.
In an illustrative embodiment, the translation user interface 402 can obtain validation results from a validation component 108. Further, the translation user interface 402 can display a marked string so that a user can modify the string such that the string satisfies the associated constraints. Still further, suggested, selectable modifications can be presented to a user so that a user may choose which modifications to apply. For example, suggested, selectable modifications can be presented as auto-completes. In an illustrative embodiment, the translation user interface 402 can obtain translated results from the translation component 404. Further, the translation user interface 402 can display the translated string to the user with markings that correspond to the associated metadata. A user can modify the translated string such that it satisfies the associated constraints. In an illustrative embodiment, translation component 404 can correspond to an auto-translation component 116, a machine translation component 118, or a manual translation component 120. Further, translation component 404 can utilize pseudo-localization techniques to provide a pseudo-localized string. Pseudo-localization techniques will be discussed in more detail below. In an illustrative embodiment, the components of the system can be distributed. For example, user interfaces 302 and 402 can exist on client machines while the one or more compiler components 104 exit on a server. Alternatively, the user interfaces 302 and 402 and one or more compiler components 104 can exist on the same machine.
With reference now to FIG. 5A, in an illustrative embodiment 500, metadata includes one or more constraints 502, 504, 506, 508, 510, 512, and 514 which correspond to evaluation criteria. The constraints can include one or more anchor points 520, 518, 516, and 522 which can be used to project the one or more constraints 502, 504, 506, 508, 510, 512, and 514 on top of a string 524. In an illustrative example, string 524 can correspond to a filename such as “CALCULATOR.EXE.” Constraints 1.1 and 1.2 (502 and 504) can be used to evaluate the portion of the string 524 between anchor points 520 and 522. Constraints 2.1, 2.2 and 2.3 (506, 508, and 510) can be used to evaluate the portion of the string 524 located between anchor points 520 and 518. Constraints 3.1 and 3.2 (512 and 514) can be used to evaluate the portion of the string 524 located between anchor points 516 and 522.
In an illustrative embodiment, multiple constraints can be placed between anchor points. Additionally, constraints are combinable thus allowing for an initial small set of constraints to represent a large number of concepts or assumptions. For example, there are several rules that can be used to lock a portion of a string while a single constraint can be used to implement the lock. Thus each of the rules when compiled would use the single lock constraint to implement the lock. Still further, the illustrative metadata can be used to process strings encoded in any character set, such as the ASCII character set or the Unicode character set.
The one or more anchor points 520, 518, 516, and 522 can be placed before or after elements in the string 524. For example, anchor point 520 is placed before element “C” 501. Similarly, anchor point 518 is placed after element “R” 503 and before element “.” 505 while anchor point 516 is placed after element “.” 505 and before element “E” 507. Likewise, anchor point 522 is placed after element “E” 509. In an illustrative embodiment, elements in a string correspond to characters, such as Unicode characters. Alternatively, elements in a string can correspond to code points, such as Unicode code points.
In an illustrative embodiment, an anchor point can be loosely anchored or hard-anchored to a point before or after any of the elements in the string. An anchor point that is hard-anchored to a point on a string is fixed to that point. Conversely, an anchor point that is loosely anchored can move within a range of points on the string. For example, a constraint can be anchored to a beginning anchor point and an ending anchor point. A constraint anchored to a loose beginning anchor point and a loose ending anchor point evaluates to “true” if the corresponding evaluation criteria can be satisfied by any sequence found between the two anchor points. Conversely, a constraint anchored to a hard beginning anchor point and a hard ending anchor point evaluates to “true” if the corresponding evaluation criteria can be satisfied by the sequence that starts at the beginning anchor point and ends at the ending anchor point. Further, a constraint that is not anchored evaluates to “true” if any sequence within the string 524 satisfies the constraint. Still further, constraints can be anchored in one manner to one anchor point and anchored in another manner to another anchor point. In regards to terminology within the present application, describing a constraint as hard-anchored to an anchor point is equivalent to describing the constraint as anchored to a hard anchor point. Similarly, describing a constraint as loosely-anchored to an anchor point is equivalent to describing the constraint as anchored to a loose anchor point. Examples of various types of anchoring will be provided below.
In an illustrative embodiment, the one or more constraints 502, 504, 506, 508, 510, 512, and 514 can be projected onto a string 524 at runtime. Further, the one or more constraints 502, 504, 506, 508, 510, 512, and 514 can be evaluated at runtime. Compiling the one or more constraints 502, 504, 506, 508, 510, 512, and 514 and one or more anchor points 520, 518, 516, and 522 from source data is more computationally intensive than projecting and validating the constraints. Therefore, allowing projection and validation of constraints against a string at runtime without requiring re-compilation provides for more efficient processing of strings. In an illustrative embodiment, the one or more constraints 502, 504, 506, 508, 510, 512, and 514 cannot be projected onto a string in a manner that would validate the string if the string is in fact invalid.
With reference now to FIG. 5B, in an illustrative embodiment 550, constraints 552, 556, 558, 560, and 562 can be used to validate string 525. For example, string 525 can be representative of a filename in a computer system that must conform to the specified constraints 552, 556, 558, 560, and 562 to be valid. Before validating string 525, constraints 552, 556, 558, 560, and 562 can be placed on top of the string 525 using anchor points 516, 518, 520, and 522. For example, projection component 110 can place constraints 552, 556, 558, 560, and 562 onto string 525 according to anchor points 516, 518, 520, and 522. In an illustrative embodiment, the constraints 552, 556, 558, 560, and 562 can be projected onto the string using the following procedure:
• (1) Identify the beginning of the string as anchor point 520.
• (2) Identify the end of the string as anchor point 522.
• (3) Add constraint 552 that requires the string to contain the sequence of elements “.” (dot).
• (4) Identify the beginning of the dot as anchor point 518.
• (5) Identify the end of the dot as anchor point 516.
• (6) Add constraint 556 anchored to anchor points 520 and 518 that requires the substring to have at most 8 elements.
• (7) Add constraint 556 anchored to anchor points 520 and 518 that requires the substring to have at least 1 element.
• (8) Add constraint 560 anchored to anchor points 520 and 518 that contains the list of invalid elements for a file name (asterisk, dot, space, etc.).
• (9) Add constraint 562 anchored to anchor points 516 and 522 that requires the substring to be the sequence of elements “exe” (case insensitive).
In this manner, a simple, small set of constraints can be used to build “complex” constraints. In an illustrative embodiment, a user may build the “complex” filename constraint described above by entering a rule corresponding to each constraint into an authoring user interface 302 and running the constraints through the illustrative operating environment 100 depicted in FIG. 3. In another embodiment, a user can simply enter a string into the authoring user interface 302 which the one or more metadata compilers 104 interprets as a filename and uses to generate the set of constraints depicted in FIG. 5B. In a further embodiment, a user can enter a source string representative of a filename and a set of attributes which instruct the one or more metadata compilers 104 to generate the set of constraints which correspond to a filename. In a further embodiment, a user can enter a source string representative of a filename and a rule, such as {FILENAME}, which compiles into constraints 552, 556, 558, 560, and 562.
The exemplary constraints 552, 556, 558, 560, and 562 depicted in FIG. 5B can be used to validate the string 525. For example, validation component 108 can utilized constraints 552, 556, 558, 560, and 562 to validate string 525. As described above, projected constraints 552, 556, 558, 560, and 562 can be hard-anchored, loosely anchored, or not anchored to the string 525. In an illustrative embodiment, the type of anchoring used to place a constraint is determined by the corresponding evaluation criteria. Constraint 552 is an example of a constraint that may not be anchored to string 525. A constraint that is not anchored to string 525 must be separated from anchor point 520 on its left side by a minimum of 0 characters towards the end and must be separated from anchor point 522 on its right by a minimum of 0 characters towards the beginning. Thus, a constraint that is not anchored evaluates to “true” if some portion of string 525 satisfies the constraint. In the illustrative example, constraint 552 evaluates to “true” because the portion of the string between anchor points 518 and 516 satisfies the constraint.
A constraint that is not anchored is equivalent to a constraint that is loosely anchored to the beginning of string 525 and loosely anchored to the end of string 525. A constraint that is loosely anchored allows elements to exist or be inserted between the portion of the string that satisfies the constraint and its anchor point. For example, a constraint that requires the sequence “CUL” to be contained between anchor points 520 and 518 can be loosely anchored to anchor point 520 and loosely anchored to anchor point 518. The loose anchoring on each end of this exemplary constraint allows string 525 to satisfy this constraint even though the sequence “CAL” exists between the beginning of the constraint and anchor point 520 and sequence “AT” exists between the end of the constraint and anchor point 518.
In an illustrative embodiment, constraint 556 is an example of a constraint that is hard-anchored to anchor point 520 and hard-anchored to anchor point 518. Hard-anchoring a constraint to an anchor point forbids elements from appearing between the anchor point and the constraint. Constraint 556 is satisfied when eight or fewer elements are contained between anchor points 520 and 518. Because the sequence contained between anchor points 520 and 518 contains exactly 8 characters, the constraint is satisfied. If the constraint were not hard-anchored to anchor points 520 and 518, then additional elements could exist between the anchor points and the constraint and thus the constraint could be satisfied in situations in which the sequence between anchor points 520 and 518 contained more than eight elements. Constraint 558 is an example of a constraint that can be hard-anchored to anchor point 520 and that can be hard-anchored to anchor point 518. Constraint 558 is satisfied when one or more items are contained between anchor points 520 and 518. Because the sequence contained between anchor points 520 and 518 contains eight items, and one≦eight, the constraint 558 is satisfied. In an alternative embodiment, constraint 558 can be hard-anchored to anchor point 520 and loosely anchored to anchor point 518.
With continued reference to FIG. 5B, constraint 560 is hard-anchored to anchor point 520 and hard-anchored to anchor point 518. Constraint 560 evaluates to “true” if each element in the sequence between anchor points 520 and 518 does not equal an asterisk, a period, or a space. Because none of the restricted items appear in the sequence between anchor points 520 and 518, the constraint evaluates to “true.” Constraint 562 is hard-anchored to anchor point 516 and hard-anchored to anchor point 522. Further, constraint 562 evaluates to “true” if the sequence between anchor points 516 and 522 is equal to the sequence “EXE” (case insensitive). Because the sequence between anchor points 516 and 522 equals “EXE”, constraint 562 evaluates to “true.” Although not depicted in FIG. 5B, a constraint that required string 525 to end with the sequence “.EXE” would be hard-anchored to anchor point 522 and either not anchored at the beginning or loosely anchored to anchor point 520. Conversely, a constraint that required string 525 to begin with the sequence “CAL” would be hard-anchored to anchor point 520 and either not anchored at the end or loosely anchored to anchor point 522.
In an illustrative embodiment, multiple types of anchor points can exist at the same point on a string. For example anchor point 522 can correspond to a loose anchor point and a hard anchor point. In an illustrative embodiment, constraint 552 could be loosely anchored to anchor point 522 whereas constraint 562 could be hard-anchored to anchor point 522.
In an illustrative embodiment, FIG. 5B depicts how string 524 from FIG. 5A could be modified such that it satisfies exemplary constraints 552, 556, 558, 560, and 562. For example, string 524 can be modified by correction component 112 such that constraints 552, 556, 558, 560, and 562 are satisfied. String 524 can be modified in an authoring user interface 302 or a translation user interface 402 according to markings on the string. Further, string 525 (“CALCULAT.EXE”) can be the result of a user entering string 524 (“CALCULATOR.EXE”) into a translation user interface 402 and validating and correcting string 524 against constraints 552, 556, 558, 560, and 562. Constraints can be configured such that they are case-sensitive or case-insensitive. For example, constraint 562 can be configured such that it is case sensitive and will only match against the sequence “EXE”. Alternatively, constraint 562 could be configured such that it is case insensitive and will match against any combination of uppercase and lowercase characters which combine to spell “exe”.
With reference now to FIG. 5C, constraints 552, 556, 558, 560, and 562 can be used in an attempt to validate string 524. In an illustrative embodiment, a user can enter string 524 into a translation user interface 402 and attempt to determine whether the string 524 is a valid filename using constraints 552, 556, 558, 560, and 562. Although constraints 552, 558, 560, and 562 evaluate to “true”, constraint 556 evaluates to “false”, and thus string 524 would not be valid. In an illustrative embodiment, it is not possible to place a set of constraints against a string in a manner that validates an invalid string. Thus, users can direct the placing of constraints against a string to be validated. This allows for compilation to take place prior to runtime while placing and validating can be performed at runtime. In a typical environment, compilation is significantly more computationally expensive than placing and validation, and thus significant efficiencies can be realized by performing compilation prior to runtime.
With reference now to FIG. 5D, several constraints 596, 590, 586, 574, 576, 578, and 584 can be projected onto an exemplary string 572 and assist in processing the string 572. In an illustrative embodiment, constraint 596 limits the portion of the string 572 before the first colon 594 to a maximum of 255 elements. In a similar manner, constraint 590 limits the portion of the string 572 after the third colon 592 and before the fourth colon 582 to a maximum of 10 elements. Similarly, constraint 586 limits the portion of the string 572 after the fourth colon 582 to a maximum of 35 elements. Because each substring contains less than the maximum number of constraints specified by the associated constraints, each of the maximum-length constraints 596, 590, and 586 is satisfied. Constraints 574, 578, and 584 forbid any of the elements in the respective, associated substrings from containing a “:” (colon). Because none of the substrings contain colons, constraints 574, 578, and 584 are satisfied. Constraints 576 and 588 are lock constraints that prevent the corresponding sequence from being localized. Thus, lock 576 prevents the substring “:12:03:” from being localized while lock 588 prevents the fourth colon 582 from being localized.
Although FIGS. 5A-5D depict strings in English, which is written from left to right, it will be appreciated that the present invention can process and translate resources in any language. For example, the present invention is aware of right-to-left languages, such as Arabic and Hebrew, and works appropriately with them. In an illustrative embodiment, the present invention conducts operations on the internal representation of a string in memory, as opposed to the display view, in order to deal appropriately with strings in any language.
In an illustrative embodiment, rules can be used to generate metadata. For example, a user can input a rule, in addition to a source string, using the authoring user interface 302. In an illustrative embodiment, a rule can be compiled into metadata including one or more constraints which correspond to evaluation criteria and one or more corresponding anchor points. Further, the metadata can be used to validate a string. Several different types of rules can be used to generate constraints. For example, the rule set (or instruction set) can include rules that correspond to fixed placeholders, numbered placeholders, escaped characters, escaped placeholder characters, invalid characters, valid characters, restrictions relating to sequences that can be used to begin or end a string, and restrictions related to sequences that must appear in the string. Further, the rule set can include a split rule and a substring rule.
In an illustrative embodiment, a placeholder can have special meaning and is analogous to a variable that needs to be replaced by its value before it is displayed. Placeholders are typically not translated by a translation component 404. For example, a set of constraints can be operable to prevent a corresponding placeholder from being translated. In an illustrative embodiment, fixed placeholders correspond to a specific type. For example, a fixed placeholder can be represented by a sequence, such as ‘%s’ or ‘%d’. Further, before a fixed placeholder is displayed it can be replaced with a value of the type specified by the fixed placeholder. For example, a fixed placeholder of the type ‘%s’ can be replaced with a string whereas a fixed placeholder of the type ‘%d’ can be replaced with an integer. In an illustrative embodiment, a fixed placeholder in a source string cannot be switched with another placeholder in the source string. Further, fixed placeholders appear in a translation in the same order as they appear in a source string. Because the ordering of fixed placeholders is preserved in a translation, the number of occurrences of fixed placeholders is implicitly preserved.
In an illustrative embodiment, a numbered placeholder corresponds to an index. Further, numbered placeholders can be swapped and repeated in a source string. Still further, numbered placeholders can exist in a translation in any order. For example, numbered placeholder ‘{0}’ may appear before numbered placeholder ‘{1}’ in a source string, but can appear after numbered placeholder ‘{1}’ in a translation. In an illustrative embodiment, fixed placeholders and numbered placeholders can be inserted into a string by a user wherever the corresponding placeholders should appear. However, in practice, a target string is not valid if the count of fixed placeholders in the target string differs from the count of fixed placeholders in a corresponding source string.
In an illustrative embodiment, a rule can indicate character or character sequences to be escaped. For example, the character ‘\’ can have special meaning within a string and should thus be escaped, such as by preceding the character with another ‘\’. In an illustrative embodiment, the syntax to create an escaped character constraint is of the form {EscapeChars, ‘x=yy’}, where ‘x’ is a sequence of characters that cannot exist in the string and ‘yy’ is a sequence of characters that should be used instead of ‘x’. Further, in an illustrative embodiment, if ‘yy’ is empty, then the corresponding ‘x’ parameter cannot exist in the string. A similar rule can indicate character or character sequences to be escaped within a string or substring, except for within the regions covered by a specific set of constraints, such as the set of constraints defined by a placeholder. This rule can prevent a user from accidentally adding a placeholder in a string.
In an illustrative embodiment, a rule can correspond to a constraint which forces a string or substring to only contain a set of characters. The characters can be defined as a regular expression span, a set of characters, or a codepage. Conversely, a rule can correspond to a constraint which forces a string or substring to not contain a set of characters. For example, constraint 560 of FIG. 5B can be generated by such a rule. Rules can also correspond to constraints which verify that a string begins, contains, or ends with a specified value. For example, in an illustrative embodiment, constraints 552 and 562 of FIG. 5B can be compiled from rules that correspond to constraints to verify whether a string contains or ends with a specified sequence of characters, respectively.
In another illustrative embodiment, a split rule can also be used to divide a string into substrings according to specified parameters. The split rule protects the section of a string covered by the parameters and requires those sections to exist in a corresponding translation. Further, sections of a string not covered by the parameters can be used as substrings. Even further, the substrings found can be used as substring parameters in other rules. Other rules can be dependent on the split rule, and thus the split rule can be processed before any rule that can use the substring parameters.
In another illustrative embodiment, a substring rule can also be used to divide a string into substrings according to specified parameters. The substring rule protects the section of a string not covered by the parameters and requires those sections to exist in a corresponding translation. Further, sections of a string covered by the parameters can be used as substrings. In a manner similar to the split rule, the substrings found can be used as substring parameters in other rules. Other rules may be dependent on the substring rule, and thus the substring rule would be processed before any rule that can use the substring parameters.
In an illustrative embodiment, substring and positional parameters can be used with the rules to generate constraints with corresponding anchor points. Positional parameters essentially expose the anchor points in a string to a user. Further, a user can specify whether a parameter is case-sensitive, case-insensitive or a regular expression. Still further, multiple types of parameters can be combined within a rule. Even further, culture parameters can be represented by numeric values or string values.
In an illustrative embodiment, positional parameters can be used to specify portions of a string to which a constraint applies. Positional parameters can use the following syntax: (s+|e−)x . . . (s+|e−)y. In the exemplary syntax, ‘x’ specifies the beginning position and ‘y’ specifies the ending position within a string. Further, ‘s+’ and ‘e−’ are optional modifiers which specify that the position is from the start or from the end of a string and that the position is anchored to that location. Parameters can operate on virtual separators between characters in a string. For example, parameter ‘s+0’ indicates the position prior to the first character in a string. Conversely, parameter ‘e−0’ indicates the position after the last character in a string. To specify a position that covers the first character in a string, parameters ‘s+0 . . . s+1’ can be used. As an example of a rule with positional parameters, the rule {ValidStrings=s+0 . . . s+2, “He”} creates a constraint on a corresponding string in which the first two characters must be ‘He’.
In an illustrative embodiment, substring parameters can be used for specifying a substring that has been generated according to a rule that divides a string. For example, the {split} rule and the {Substring} rule can be used to divide a string into substrings. Substrings can be numbered using a zero-based index calculated from the beginning of the original undivided string. Substring parameters can use the syntax s‘x−y’, where x is the first substring and −y is optional and describes a range of substrings. Still further, by using the literal character ‘x’ as opposed to a non-negative number, the ‘x’ is replaced by the last substring found in the original string. Alternatively, by using a substring parameter of “s‘*’”, the rule applies to all substrings. As an example of how substring parameters can be used, if a user enters the string “Excel files|*.xls|All Files|*.*” along with the rules {Split=“|”} and {Lock=s‘1’,s‘3’} into the authoring user interface 302, the string will be split on the ‘|’ character. Further, the first and third substrings—‘|*.xls|’ and ‘|*.*’—generated by the split rule will not be localized according to the lock instruction.
FIG. 6 is a flow diagram illustrative of a source-data processing routine 600 which can be implemented by the illustrative operating environment 100 depicted in FIG. 3 in accordance with an aspect of the present invention. At block 602, the one or more metadata compilers 104 obtains source data. In an illustrative embodiment, the source data is in the form of user input from an authoring user interface 302. Further, the source data can include a source string. Still further, the source data can include attributes, such as an instruction, additional resource information, and/or an inferred restriction. In an illustrative embodiment, a façade component can direct the source data from the authoring user interface 302 to the appropriate metadata compiler based on the characteristics of the source data. At block 604, the source data is compiled into metadata. In an illustrative embodiment, the metadata can include one or more constraints which correspond to evaluation criteria and one or more anchor points operable to project the constraints onto a string.
At block 604, the metadata optimizer and arbitrator 106 normalizes the metadata. FIG. 8 is a flow diagram of a normalization sub-routine 800 implemented by the metadata optimizer and arbitrator 106 in accordance with an aspect of the present invention. At block 802, the metadata optimizer and arbitrator 106 obtains abstract metadata. In an illustrative embodiment, the abstract metadata can be obtained from one or more metadata compilers 104. At block 804, the metadata optimizer and arbitrator 106 reduces redundant constraints to a single equivalent constraint. For example, if one constraint on a target string specifies a maximum length of twenty elements while another constraint on the target string specifies a maximum length of ten, then the metadata optimizer and arbitrator 106 can reduce the two constraints to a single equivalent constraint specifying a maximum length of ten. The metadata optimizer and arbitrator can make this reduction because any string shorter containing fewer than ten elements will also contain fewer than twenty elements.
At block 806, the metadata optimizer and arbitrator performs conflict resolution. Conflict resolution can include resolving incompatibilities amongst a plurality of constraints. For example, one constraint can specify a maximum length of ten while another constraint specifies a minimum length of twenty. Clearly, no single string can satisfy both of these constraints and thus the constraints are incompatible. The metadata optimizer and arbitrator 106 can resolve the incompatibility. In an illustrative embodiment, the optimizer 106 can resolve the conflict by simply picking one constraint and discarding the other. Further, the metadata optimizer and arbitrator 106 can provide a warning that an incompatible constraint is being discarded. Alternatively, a user or administrator can decide which constraint to keep. In an illustrative embodiment, incompatibilities can be resolved based on other attributes associated with a source or target string. Incompatible and/or redundant constraints can be generated by multiple metadata compilers 104 or can be generated by a single metadata compiler 104. In an illustrative embodiment, the metadata optimizer and arbitrator 106 makes no assumptions about inputs. For example, the optimizer 106 does not assume that metadata from a single compiler is free of incompatible or redundant constraints. At block 808, the sub-routine 800 returns to routine 600.
Returning to FIG. 6, at block 608 a projection component 110 projects metadata onto a string. The string can be a target string entered by a user at the translation user interface 402. Further, the metadata can be normalized, abstract metadata obtained from the metadata optimizer and arbitrator 106. In an illustrative embodiment, projecting metadata onto a string involves placing constraints and their associated evaluation criteria on top of the string according to the corresponding one or more anchor points. For example, constraints 552, 556, 558, 560, and 562 can be projected onto string “CALCULAT.EXE” 525 using anchor points 520, 518, 516, and 522 as depicted in FIG. 5B.
At block 610, a validation component 108 validates a string against the projected metadata. In an illustrative embodiment, validating a constraint involves evaluating the portion of the string to which the constraint is mapped to determine whether the mapped portion satisfies the evaluation criteria that corresponds to the constraint. For example, constraint 556 in FIG. 5B is evaluated by determining whether the portion of the string between anchor points 520 and 518 has less than 8 elements. Because the portion of the string to which the constraint 556 is mapped (“CALCULAT”) has less than 8 elements, the constraint evaluates to “true.” In an illustrative embodiment, validation component 108 continues processing the other constraints associated with a string until all constraints have been evaluated. Further, in an illustrative embodiment, a string is valid if all associated constraints evaluate to “true.” A string is not valid if any of the constraints evaluate to “false.” Nevertheless, a string can be valid if some constraints are not satisfied. For example, if a failed constraint generates a warning message as opposed to an error message, then a corresponding string can still be valid.
At block 612, a validated string along with the metadata used to validate the string can be displayed to a user. In an illustrative embodiment, a string and combined metadata can be displayed on an authoring user interface 302. Further, the metadata can be used to mark a string such that a user can determine which portions of the string are valid and which portions are not valid. Marking and displaying a string will be discussed in more detail below in relations to FIGS. 12-15. At block 614, the routine 600 terminates.
FIG. 7 is a flow diagram illustrative of a target-data processing routine 700 which can be implemented by the illustrative operating environment 100 depicted in FIG. 4 in accordance with an aspect of the present invention. At block 702 a projection component 110 obtains target data and metadata. In an illustrative embodiment, the projection component 110 can obtain target data from a translation user interface 402. Further, the target data can include a target string. Still further, the target data can include attributes corresponding to the string. In an illustrative embodiment, the projection component 110 can obtain normalized abstract metadata from the metadata optimizer and arbitrator 106. Alternatively, the projection component 110 can obtain metadata from a data store.
At block 704, the projection component 110 projects metadata onto the target string. Examples of strings with projected metadata are depicted in FIGS. 5B-5D. At block 706, a validation component 108 validates the target string. In an illustrative embodiment, the metadata obtained at block 702 can include constraints operable to validate a particular type of string, such as a filename, and the target data can include a string to be validated for conformity with the requirements of the particular type of string.
With continued reference to FIG. 7, at block 708, a translation component 404 translates the target. Lock constraints can be mapped to one or more portions of a target string and thus restrict the one or more portion of the string from being translated. For example, a placeholder restriction can prevent a corresponding placeholder in a target string from being translated. In an illustrative embodiment, a string can be translated from any source language to any target language. Further, the translation component 404 can perform pseudo-localization of a string. Pseudo-localization will be discussed in more detail below. At block 710, the translated target can be corrected. For example, the translated target string may not satisfy the constraints included in the projected metadata. A string that does not satisfy associated constraints can be modified such that the modified string satisfies the constraints. For example, string 524 from FIG. 5A can be modified by deleting “OR” to conform with the constraints 552, 556, 558, 560, and 562 depicted in FIG. 5B. At block 712, the translation and associated metadata is displayed to a user. In an illustrative embodiment, the translation can be displayed on translation user interface 402. Further, the associated metadata can be used to mark the string. Marking of a string will be discussed in more detail below. At block 714, the routine 700 terminates.
FIG. 9 is a block diagram 900 depicting the conversion of data from one or more resources into a resource-neutral format before being translated. In an illustrative embodiment, string “FOO {0}” can be associated with Resource A 902. Further, the substring “{0}” from “FOO {0}” can be associated with a placeholder restriction. A placeholder restriction can prevent an associated placeholder within a string from being translated. String “FOO %1” can be associated with Resource B 904. Further, the substring “%1” from “FOO %1” can be associated with a placeholder restriction. In an illustrative embodiment, Resource A 902 can be associated with one particular platform, whereas Resource B can be associated with a different platform.
Block 906 depicts the conversion of strings “FOO {0}” and “FOO %1” into a resource neutral format. In an illustrative embodiment, the respective placeholders “{0}” and “%1” can be converted into a resource neutral form (e.g., “<PH\>”). Between blocks 906 and 908, a pseudo-translation of the string can be performed to generate string “fÕÕ <PH\>”, which is depicted at block 908. The placeholder restriction can prevent the placeholder (“<PH\>”) from being pseudo-localized. At block 910, the string “fÕÕ <PH\>” can converted back into the resource-dependent form “fÕÕ {0}” which is dependent upon Resource A. Similarly, at block 912, the string “fÕÕ <PH\>” can be converted back into the resource-dependent form “fÕÕ {0}” which is dependent upon Resource B. By converting resource-dependent strings into a resource-neutral format before translating or performing other actions on the strings, the translating or processing code can be made simpler because the code only has to process data in a single resource-neutral format. In an illustrative embodiment, resource neutralization can be used to translate strings that differ only on locked portions. Further, placeholders and escaped characters are resource-dependent and can be transformed into resource-neutral forms.
FIG. 10 is a flow diagram illustrative of a fuzzying routine 1000 implemented by a translation component 404 in accordance with an aspect of the present invention. At block 1002, the translation component 404 obtains metadata that has been projected onto a string. At block 1004, resource-format neutralization can be performed on the string. As discussed above in relation to FIG. 9, resource-format neutralization can be used to convert resource-dependent portions of a string into a single resource-neutral format. At block 1006, random content is generated. The random content can be representative of a translated version of the string included in the projected metadata.
At block 1008, the metadata obtained at block 1002 is projected onto the random content. Further, at block 1010, the projected metadata can be used to modify the random content such that the random content satisfies the projected constraints. The projected metadata can include placeholders and escaped characters which are inserted into the random content such that the random content satisfies the projected constraints. At block 1012, any resource-neutral constraints that were inserted into the random content so that the random content would satisfy the projected constraints are converted into resource-dependent form. The fuzzying routine 1000 can be used to generate random content which satisfies metadata associated with a source string. In this manner, the fuzzying routine 1000 can create various pseudo-translations of a string which can be used for testing purposes. At block 1014, the routine 1000 terminates.
FIG. 11 is a flow diagram illustrative of a regular expression conversion routine 11000 implemented by a metadata compiler 104 in accordance with an aspect of the present invention. In an illustrative embodiment, regular expressions can be converted into metadata including one or more constraints which correspond to evaluation criteria and one or more corresponding anchor points. Converting regular expressions into metadata can simplify the metadata normalization and translation processes. At block 1102, the one or more metadata compilers 104 obtains a regular expression and a source string from an authoring user interface 302. For example, a metadata compiler 104 can obtain a source string such as “This is aa file” and a regular expression rule such as {Regex=“a{2}”} from the authoring user interface 302. Regular expressions are well-known in the art and the one or more metadata compilers 104 are operable to process any regular expression. At block 1104, the one or more metadata compilers 104 can parse the regular expression such that metadata including one or more constraints and one or more corresponding anchor points can be derived from the regular expression.
With continued reference to FIG. 11, at block 1106, the metadata expression is matched against the source string. At block 1108, the constraints can be projected onto the source string Using the example regular expression {Regex=“a{2}”} and the example source string of “This is aa file”, a lock constraint can be placed on the first occurrence of two consecutive ‘a’ characters in the source. Thus, a lock constraint can be placed on ‘aa’ in the source string “This is aa file”. In another example, the one or more metadata compilers 104 can obtain the exemplary regular expression {Regex=“a [abc] {3}”} to be matched against the exemplary source string “This is abbc file.” The exemplary regular expression can be parsed to create a lock constraint on the first occurrence of an ‘a’ followed by three letters that are either ‘a’, ‘b’, or ‘c’, in addition to a valid characters constraint on the following three characters which must be either ‘a’, ‘b’, or ‘c’. Additionally, a maximum length constraint with length 3 and a minimum Length constraint with length 3 would cover the same section. Matching the derived constraints to the exemplary source string “This is abbc file” would create a lock constraint on ‘a’ and the valid characters constraint, maximum length constraint, and minimum length constraint on the ‘bbc’ portion of the source string. In an exemplary embodiment, because the source string satisfies all constraints, the source string is valid. At block 1110, the routine 1100 terminates.
Referring back to FIG. 5D, in an illustrative embodiment, the split rule can be used with a regular expression parameter to generate some of the depicted constraints. For example, if a user wants to generate constraints such that only text sections of string 572 will be translated, a user can split the string using a regular expression. An exemplary split rule such as {Split=r“: [0-9:]*:?”} can be used to perform the split. The ‘r’ parameter in the rule can indicate that what follows is a regular expression. Further, the one or more metadata compilers 104 converts the regular expression into lock constraints 576 and 588. Still further, the split rule generates substrings “FLY FROM BOTTOM”, “FLY”, and “FROM BOTTOM”.
As discussed above, the substrings generated by a split rule can be used as parameters in other instructions. Thus, in addition to the split rule above, in an illustrative embodiment, a user can enter other rules using the substrings generated from the split rule as parameters. For example, to generate constraints 574, 578, and 584, a user can enter a rule of the form: {InvalidChars=s‘0-2’, “:”}. The ‘s’ parameter can indicate that the instruction will generate constraints for the substrings 0, 1, and 2, which were generated by the split rule above. Thus, combining the split rule discussed above with an invalid characters rule, a user can restrict the substrings “FLY FROM BOTTOM”, “FLY”, and “FROM BOTTOM” from containing the sequence “:” as indicated by constraints 574, 578, and 584. Further, a user can use the substrings generated from the split rule as parameters in a rule to restrict maximum length. For example, a rule of the form: {MaxLen=s‘0’, 255} can be used to generate constraint 596. Likewise, an exemplary rule such as {MaxLen=s‘1’, 10} can generate constraint 590 while an exemplary rule such as {MaxLen=s‘2’, 35} can generate constraint 586.
FIGS. 6-11 illustrate various methods that may be performed according to various aspects of the present invention. However, it will be appreciated that the present invention can perform more or fewer methods than depicted by the illustrative figures. Further, the methods illustrated within each individual figure may include more or fewer elements than depicted in the illustrative figures.
With reference now to FIG. 12, an illustrative user interface 1200 for displaying a string 1214 along with associated comments 1202, suggested values 1228 and 1236, and a translation 1244 will be described. In an illustrative embodiment, a comment display portion 1206 can be operable to obtain and display comments associated with the string 1214. Comments can correspond to attributes. Comments can also correspond to rules that the one or more metadata compilers 104 can compile into constraints. For example, a user may enter a rule of the form {MaxLen=17} 1204 into the comment display portion 1206 to indicate that a maximum-length constraint operates on the entire string and limits valid strings to containing no more than 17 elements. Placeholders, escaped characters, valid and invalid characters, substring, split, and other types of constraints can be placed on a string 1214 by entering the corresponding rule into the comment display portion 1206 of the display 1200. Alternatively, a metadata compiler 104 can infer constraints by analyzing string 1214. In an illustrative embodiment, comments can also include resource information. Additionally, syntax errors in the comment display portion 1206 can be marked. Still further, rules can be marked if the corresponding string fails to validate against the rule. For example, the number “17” is underlined in rule {MaxLen=17} 1204 because the corresponding string 1214 contains more than 17 characters.
An input string display portion 1280 can be used to obtain and display a string 1214. In an illustrative embodiment, the value of the string 1212 is displayed as “The saving of file %1!s! is %2!d! % complete” 1214. Additionally, the string 1214 can be marked to alert the user of any constraints on the string 1214. For example, the word “file” 1216 is italicized to indicate that file is subject to a term constraint. Further, “%1!s!” 1218 is underlined to indicate a placeholder. As discussed above, a placeholder prevents the corresponding portion of the string from being translated. Likewise, “%2!d!” is also underlined to indicate a placeholder. As will be discussed in more detail below, placeholders 1218 and 1220 in the input string display portion 1280 may not be translated in the translation display portion 1286.
A percent sign (“%”) 1224 can be marked with an arrow 1222 to indicate an escaped character constraint. However, any type of marking can be used to mark any of the constraints associated with the string 1214. For example, highlighting, color-coding, underlining, bold, italics, special characters, shading, arrows, or any other techniques can be used to mark the string 1214. Additionally, a string can be edited at a resource-neutral level. For example, string 1214 could be converted to a resource-neutral format and displayed to a user for editing. Further, a string can be displayed and edited in a format that corresponds to any resource. For example, a string corresponding to an exemplary resource A could be converted into a resource-neutral format and then resource-injected such that the string is displayed and editable in a format corresponding to an exemplary resource B.
Suggested value 1226 display portions 1282 and 1284 can be used to display suggested modifications 1228 and 1236 for input string 1214. For example, display portion 1282 may suggest that the percent sign (“%”) 1224 be escaped 1234 because a certain resource interprets the percent sign 1224 as a special character. By escaping the percent sign 1234, the resource will not give the percent sign its special meaning. Similarly, display portion 1284 may suggest that the percent sign 1224 be replaced with the word “percent” 1238. A user may select one or more of the suggested values 1228 and 1236 for translation. The suggested values 1228 and 1236 can have more or fewer placeholders than the input string 1214. Additionally, metadata in the suggested values 1228 and 1236 can be visually indicated using various marking techniques. Suggested values 1228 and 1236 can be generated by a translation memory, by machine translation, or through other translation techniques. Further, suggestions can appear on the display 1200 as auto-completes as the user types.
In an illustrative embodiment, the input string display portion 1280 and suggested value display portions 1282 and 1284 can be associated with graphics that indicate confidence levels 1208 and translation availability 1210. For example, input string 1214 can be associated with a graphic 1290 that indicates how difficult it would be to machine translate. Further, a graphic 1254 can indicate the number of languages to which a string can be translated. For example, graphic 1254 can indicate that a translation memory has 0 associated translations for the particular input string 1214. Each suggested value display portion 1282 and 1284 can also be associated with a graphic 1292 and 1294 that indicates how difficult the respective, associated suggested values 1228 and 1236 would be to machine translate. Graphic 1292 visually indicates that suggested value “Saving file %1!s!. %2!d! %% complete.” 1228 is available in 2 languages 1252, whereas graphic 1294 visually indicates that suggested value “Saving file %1!s!. %2!d! percent complete.” 1236 is available in 15 languages 1250. The illustrative user interface 1200 can also include a graphic 1248 that visually indicates which suggested value is available in the most languages. Additionally, translation availability graphics 1210 and/or confidence level graphics 1208 can correspond to a specific market or markets.
In an illustrative embodiment, a translation 1244 of the source string 1214 or a suggested value 1228 or 1236 can be provided in a translation display portion 1286. In an illustrative embodiment, the translation can be a sample (pseudo) translation 1242, which can be produced using the fuzzying technique described above in relation to FIG. 10, for example. Additionally, a translation can be into any language. Typically, placeholders 1220 and 1218 will not be translated. Further, placeholders can be associated with functional portions of the string. In an illustrative embodiment, translation 1244 can be the result of a fuzzying technique that first generated random content and then corrected the random content according to metadata including one or more constraints and one or more corresponding anchor points. For example, placeholders 1220 and 1218 could have been placed in the random content to satisfy the constraints associated with the metadata of the corresponding source string 1214.
Spell-checking can be incorporated into the display 1200 and suggest corrections to misspelled words. Further, terms can be described as a mouse pointer hovers over the terms. Still further, differences between suggested values 1228 and 1236 and the input string 1214 can be marked to provide the user with a quick visual indication of the differences. Additionally, an indication of how input strings can be used can be provided. Further, terms can be marked to indicate that they are approved by certain organizations or groups. The display 1200 can be configurable such that the user can turn features on and off. Markings can be used to indicate any terms that have been replaced in the source string 1214. If a certain portion of a string is associated with a low confidence level, that portion can be indicated with markings. Additionally, functional problems in a translation 1244 can be marked and suggestions to correct functional problems can be displayed.
With reference now to FIGS. 13-15, an illustrative user interface 1300 for translating a source string 1504 in a source language into a target string 1516 in a target language will be described. As depicted on the overlaid diagram, on a high level, an item with projected metadata 1520 can be entered into an input string display portion 1502, the metadata can be projected onto a target string and validated 1522, and the target string 1516 can be displayed as an item with projected metadata 1524 on a translation display portion 1512. FIGS. 13-15 depict an exemplary iterative process a user can utilize to generate a target string 1516 that satisfies the metadata associated with a corresponding source string 1504.
With reference now to FIG. 13, tables representative of projected metadata 1526 and 1550 can be associated with the source string 1504 and target string 1516, respectively. Column 1536 of table 1526 can indicate the type of metadata, column 1538 can indicate which data from the string is associated with the metadata, and column 1540 can indicate the position of the metadata in relation to the string. Each constraint in the source string 1504 can be represented by a row in the displayed projected metadata table 1526. For example, row 1528 can indicate that a term constraint with an associated identification of “7” can be found between positions 8 and 12 on the source string 1504. The term constraint can correspond with the term “file” 1506. Term constraints in a source string can map to an equivalent term in a target string. Continuing with the example, row 1530 can indicate that an indexed placeholder represented by “{0}” 1508 can be found between positions 13 and 16 on the source string 1504. Similarly, row 1532 can indicate that an indexed placeholder represented by “{1}” 1510 can be found between positions 18 and 21 on the source string 1504. Row 1534 can indicate that a ‘{’ character and a ‘}’ character are subject to escaped character constraints and may be found anywhere within the source string 1504. Additionally, row 1534 can indicate that special character “{” can be escaped by the sequence “{{” while special character “}” can be escaped by the sequence “}}”. Because the special characters “{” and “}” in the source string 1504 are not escaped, source string 1504 does not contain any escaped characters, except on the placeholders within the string. In addition to displaying the position of constraints on a string, the type or types of anchoring associated with a constraint can be displayed. For example, placeholders “{0}” 1508 and “{1} 1510 can be loose anchored to the beginning and end of string 1504. An indication that placeholders 1508 and 1510 are loosely anchored to the beginning and end of the string can be displayed. Conversely, the escaped characters 1534 would be hard-anchored to the beginning and end of string 1504. An indication that the escaped characters constraint 1534 is hard-anchored to the beginning and end of the string can be displayed.
Still with reference to FIG. 13, various markings can be used as indicators in accordance with the metadata 1526 associated with the source string 1504. For example, bold font can be used in the source string 1504 to indicate that the term “file” 1506 is subject to a term constraint. Likewise, bold font can be used to mark the first indexed placeholder “{0}” 1508 and the second indexed placeholder “{1}” 1510. However, any type of marking can be used to visually alert a user to the metadata associated with a string. For example, italicized and other types of fonts, larger or smaller fonts, color-coding, extraneous characters on the display, highlighting, underlining, and shading can all be used to visually set off portions of a string that are associated with metadata.
A table of attributes 1512 and 1514 can be associated with the source 1504 and target 1516 strings respectively. The attribute tables 1512 and 1514 can indicate the associated resource or platform in addition to the usage of the string. For example, a string can be used in a dialog box. Further, the attribute tables 1512 and 1514 can indicate an identification of the platform and the language of the associated string. As discussed above, resource neutralization can be used to translate a string from a language on one platform into a different language on another platform. By using resource neutralization, a neutralized string can be translated once and then the resource-neutral portions of the string can be converted into resource-dependent portions such that the single translation can be used on several different resources. Thus, only one resource-neutral string is translated as opposed to several resource-dependent strings.
Table 1542 can be used to display abstract metadata pulled from the projected metadata displayed in table 1526. Abstract metadata can be placed against a string for validation. Because abstract metadata is not associated with a string, table 1542 may not include a position column 1540. Table 1544 can display information related to the translation. For example, a terminology provider and associated identification can be displayed. Column 1546 can display the source and target language of a corresponding term 1506. Additionally, column 1548 can display the source and target values of a corresponding term 1506. Suggested translations for other terms in the source string 1504 can also be displayed. Accordingly, table 1544 can assist the user in translating terms correctly.
As depicted in FIG. 13, a user can begin the process of translating source string 1504 by typing “Die Dat” 1516 into the target string display portion 1512. “Dat” 1552 can be marked in bold because it can be recognized as the beginning of the translation for “file” 1506 as displayed in table 1544. Additionally, table 1550 can be utilized by a user to determine which constraints are satisfied and which are not satisfied. For example, table 1550 displays the metadata gathered from the source string and its corresponding position 1540 on the target string 1516. Because the phrase “Die Dat” 1516 does not fulfill the requirements of the constraints shown in table 1550, the position column 1540 displays a “Not Found” message for each corresponding constraint. Further, table 1550 can display warning and error messages 1554, 1556, and 1558. For example, row 1554 can display a warning message indicating that the required term “Datei” has not been completely entered. Further, rows 1556 and 1558 can display error messages indicating that placeholders “{0}” 1508 and “{1}” 1510 are missing. Using these warning and error messages, a user can begin to correct the translation 1516. Alternatively, suggested corrections can be displayed as auto-completes for selection by the user.
As depicted in FIG. 14, a user can continue to enter a translation 1516 of the source string 1504. For example, a user can enter a translation 1518 of the required term “file” 1506. The translated term 1518 can be identified between positions 4 and 9 on the target string display portion 1512 as depicted in row 1576. Further, indexed placeholder “{0}” 1508 can be identified between positions 10 and 13 on the target string display portion 1512 as depicted in row 1578. Still further, the beginning of indexed placeholder “{1}” 1570 can be identified. In an illustrative embodiment, because indexed placeholder “{1}” 1510 is not entered correctly, the placeholder is labeled as “Not Found” in row 1580. Alternatively, because character “{” in item 1570 is unescaped and a required placeholder is missing, an error can be displayed as depicted in row 1574 indicating that item 1570 is invalid.
Still with reference to FIG. 14, various markings can be used as indicators in accordance with the metadata 1550 associated with the target string 1516. For example, bold font can be used to indicate that the term “Datei” 1518 is required in the target string 1504. Likewise, bold font can be used to mark the first indexed placeholder “{0}” 1508. Further, items that could correspond to a constraint when completely entered, such as item 1570, can also be marked in bold font. Any type of marking can be used to visually alert a user of the metadata associated with a string. For example, italicized and other types of fonts, larger or smaller fonts, color-coding, extraneous characters on the display, highlighting, underlining, and shading can all be used to visually set off portions of a string that are associated with metadata.
To assist in generating a valid target string 1516, error messages 1572 and 1574 can alert a user to portions of the string which do not satisfy the associated metadata. For example, row 1572 can indicate to the user that placeholder “{1}” 1510 is missing from the target string 1516. Still further, row 1574 can notify the user of an unescaped escape character. Because escape characters have special meaning, they can either be escaped or correspond to a constraint. A user can utilize the metadata 1550 and error messages 1572 and 1574 to generate a valid target string 1516.
FIG. 15 depicts an illustrative embodiment in which a valid target string 1516 has been entered into the target string display portion 1512. As described above, items 1518, 1508, and 1510 of the target string 1516 can correspond to constraints and can be marked in bold. Further, the position of each corresponding item can be depicted in column 1540. For example, column 1540 indicates that required term “Datei” 1518 can be found between positions 4 and 9 on the target string display portion 1512. Likewise, indexed placeholder “{0}” 1508 can be found between positions 10 and 13 while indexed placeholder “{1}” can be found between positions 28 and 31. Additionally, the lack of error and warning messages in table 1550 can indicate that a valid target string 1516 has been entered in the target string display portion 1512. Further, if any escaped characters are identified, the position of the escaped characters can be provided in column 1540 at row 1582.
While illustrative embodiments have been illustrated and described, it will be appreciated that various changes can be made therein without departing from the spirit and scope of the invention.
Claims (20)
1. A method, in a computer system, for processing source data, the method comprising:
providing an authoring user interface;
receiving one or more rules input by a user of the computer system via the authoring user interface, the one or more rules specifying valid formatting conditions for at least one text string to be displayed by a computer program to alert a user of the computer program to a status condition during execution of the computer program, the at least one text string comprising a string of one or more elements;
generating, using the computer system, one or more constraints and one or more anchor points based on the one or more rules, each of the one or more anchor points specifying a position before a first element of the string, between two consecutive elements of the string, or after a last element of the string, and each of the one or more constraints specifying at least one valid formatting condition with which a portion of the string in a defined position relative to at least one of the anchor points must comply;
projecting the one or more constraints onto a target string according to the one or more anchor points to determine, for each of the one or more constraints, whether the portion of the target string in the defined position relative to the corresponding at least one of the anchor points complies with the corresponding at least one valid formatting condition; and
projecting the one or more constraints onto a translation of the target string according to the one or more anchor points to determine, for each of the one or more constraints, whether the portion of the translation of the target string in the defined position relative to the corresponding at least one of the anchor points complies with the corresponding at least one valid formatting condition.
2. The method as recited in claim 1, wherein the generating comprises defining at least one fixed placeholder corresponding to at least one type within a source string, and wherein determining whether the target string complies with the valid formatting conditions comprises determining whether each fixed placeholder appears once in the target string in an order corresponding to an ordering of fixed placeholders in the source string.
3. The method as recited in claim 1, wherein the generating comprises defining at least one numbered placeholder corresponding to at least one index within a source string, and wherein determining whether the target string complies with the valid formatting conditions comprises determining whether indices appearing in the target string also appear in the source string.
4. The method as recited in claim 1, wherein the generating comprises defining a first sequence of characters to be used in place of a second sequence of characters.
5. The method as recited in claim 1, wherein the generating comprises defining a set of characters corresponding to at least a portion of the target string, and wherein the target string does not comply with the valid formatting conditions if any character in the set appears in the at least a portion of the target string.
6. The method as recited in claim 1, wherein the generating comprises defining a set of characters corresponding to at least a portion of the target string, and wherein the target string does not comply with the valid formatting conditions if any character outside of the set appears in the at least a portion of the target string.
7. The method as recited in claim 1, wherein the generating comprises defining a sequence of characters corresponding to at least a portion of the target string, and wherein the target string does not comply with the valid formatting conditions if the sequence does not appear in the at least a portion of the target string.
8. The method as recited in claim 1, wherein the projecting comprises splitting the target string into one or more substrings, and wherein the one or more substrings correspond to portions of the target string covered by one or more parameters.
9. The method as recited in claim 1, wherein the projecting comprises splitting the target string into one or more substrings, and wherein the one or more substrings correspond to portions of the target string not covered by one or more parameters.
10. A non-transitory computer-readable storage medium encoded with computer-executable instructions that, when executed, perform a method for processing source data, the method comprising:
providing an authoring user interface;
receiving one or more rules and at least one parameter input by a user of the computer system via the authoring user interface, the one or more rules specifying valid formatting conditions for at least one text string to be displayed by a computer program to alert a user of the computer program to a status condition during execution of the computer program, the at least one text string comprising a string of one or more elements;
generating one or more constraints and one or more anchor points based on the one or more rules and the at least one parameter, each of the one or more anchor points specifying a position before a first element of the string, between two consecutive elements of the string, or after a last element of the string, and each of the one or more constraints specifying at least one valid formatting condition with which a portion of the string in a defined position relative to at least one of the anchor points must comply;
projecting the one or more constraints onto a target string according to the one or more anchor points to determine, for each of the one or more constraints, whether the portion of the target string in the defined position relative to the corresponding at least one of the anchor points complies with the corresponding at least one valid formatting condition; and
projecting the one or more constraints onto a translation of the target string according to the one or more anchor points to determine, for each of the one or more constraints, whether the portion of the translation of the target string in the defined position relative to the corresponding at least one of the anchor points.
11. The non-transitory computer-readable storage medium as recited in claim 10, wherein the generating comprises using the at least one parameter to identify at least a portion of the at least one text string on which the one or more rules operate.
12. The non-transitory computer-readable storage medium as recited in claim 10, wherein the generating comprises interpreting the at least one parameter as a literal parameter.
13. The non-transitory computer-readable storage medium as recited in claim 10, wherein the at least one parameter corresponds to at least one substring generated by a rule component.
14. The non-transitory computer-readable storage medium as recited in claim 10, wherein the at least one parameter is case-sensitive.
15. The non-transitory computer-readable storage medium as recited in claim 10, wherein the at least one parameter is case-insensitive.
16. The non-transitory computer-readable storage medium as recited in claim 10, wherein the at least one parameter corresponds to at least one regular expression.
17. A method, in a computer system, comprising:
providing an authoring user interface;
receiving input from a user of the computer system via the authoring user interface, the input comprising a source string and a regular expression separate from the source string, the regular expression specifying a valid pattern of characters for at least one text string;
parsing the regular expression;
matching the regular expression against the source string, using the computer system, to generate metadata corresponding to one or more constraints and one or more anchor points, the one or more constraints specifying the valid pattern of characters, and each of the one or more anchor points specifying a position, before a first element of the source string, between two consecutive elements of the source string, or after a last element of the source string, that contains the valid pattern of characters specified by the regular expression; and
projecting the one or more constraints according to the one or more anchor points onto a target string, different from the source string, to determine whether the target string contains the valid pattern of characters at the one or more positions specified by the one or more anchor points.
18. The method as recited in claim 17, wherein the generating comprises analyzing the source string and inferring the metadata from the analysis of the source string.
19. The method as recited in claim 17, wherein the method further comprises:
normalizing the metadata such that redundant constraints are reduced to a single equivalent constraint and conflicts amongst incompatible constraints are resolved.
20. The method as recited in claim 19, wherein the method further comprises:
pseudo-localizing a string according to the normalized metadata.
US11408843 2006-04-21 2006-04-21 User declarative language for formatted data processing Active 2030-07-29 US8171462B2 (en)
Priority Applications (1)
Application Number Priority Date Filing Date Title
US11408843 US8171462B2 (en) 2006-04-21 2006-04-21 User declarative language for formatted data processing
Applications Claiming Priority (1)
Application Number Priority Date Filing Date Title
US11408843 US8171462B2 (en) 2006-04-21 2006-04-21 User declarative language for formatted data processing
Publications (2)
Publication Number Publication Date
US20070250811A1 true US20070250811A1 (en) 2007-10-25
US8171462B2 true US8171462B2 (en) 2012-05-01
Family
ID=38620902
Family Applications (1)
Application Number Title Priority Date Filing Date
US11408843 Active 2030-07-29 US8171462B2 (en) 2006-04-21 2006-04-21 User declarative language for formatted data processing
Country Status (1)
Country Link
US (1) US8171462B2 (en)
Cited By (2)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8549492B2 (en) 2006-04-21 2013-10-01 Microsoft Corporation Machine declarative language for formatted data processing
US20140282439A1 (en) * 2013-03-14 2014-09-18 Red Hat, Inc. Migration assistance using compiler metadata
Families Citing this family (12)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8495578B2 (en) * 2005-12-19 2013-07-23 International Business Machines Corporation Integrated software development system, method for validation, computer arrangement and computer program product
US20090037830A1 (en) * 2007-08-03 2009-02-05 International Business Machines Corporation Software solution for localization of software applications using automatically generated placeholders
US8069434B2 (en) * 2007-10-29 2011-11-29 Sap Ag Integrated model checking and issue resolution framework
US7975217B2 (en) * 2007-12-21 2011-07-05 Google Inc. Embedding metadata with displayable content and applications thereof
US8341598B2 (en) 2008-01-18 2012-12-25 Microsoft Corporation Declartive commands using workflows
US8321833B2 (en) * 2008-10-03 2012-11-27 Microsoft Corporation Compact syntax for data scripting language
US8266135B2 (en) * 2009-01-05 2012-09-11 International Business Machines Corporation Indexing for regular expressions in text-centric applications
US9389840B2 (en) * 2009-02-11 2016-07-12 Johnathan Mun Compiled and executable method
CN101794219B (en) * 2009-12-30 2012-12-12 飞天诚信科技股份有限公司 Compression method and device of .net files
US9116680B2 (en) 2012-09-26 2015-08-25 International Business Machines Corporation Dynamically building locale objects or subsections of locale objects based on historical data
US9778917B2 (en) 2012-09-26 2017-10-03 International Business Machines Corporation Dynamically building subsections of locale objects at run-time
US9141352B2 (en) * 2012-09-26 2015-09-22 International Business Machines Corporation Dynamically building locale objects at run-time
Citations (73)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5251130A (en) 1991-04-18 1993-10-05 International Business Machines Corporation Method and apparatus for facilitating contextual language translation within an interactive software application
US5263162A (en) * 1990-11-07 1993-11-16 Hewlett-Packard Company Method of validating a label translation configuration by parsing a real expression describing the translation configuration
US5442546A (en) * 1991-11-29 1995-08-15 Hitachi, Ltd. System and method for automatically generating translation templates from a pair of bilingual sentences
US5475586A (en) * 1992-05-08 1995-12-12 Sharp Kabushiki Kaisha Translation apparatus which uses idioms with a fixed and variable portion where a variable portion is symbolic of a group of words
US5579223A (en) * 1992-12-24 1996-11-26 Microsoft Corporation Method and system for incorporating modifications made to a computer program into a translated version of the computer program
US5644775A (en) * 1994-08-11 1997-07-01 International Business Machines Corporation Method and system for facilitating language translation using string-formatting libraries
US5644774A (en) * 1994-04-27 1997-07-01 Sharp Kabushiki Kaisha Machine translation system having idiom processing function
US5646840A (en) * 1992-11-09 1997-07-08 Ricoh Company, Ltd. Language conversion system and text creating system using such
US5659765A (en) * 1994-03-15 1997-08-19 Toppan Printing Co., Ltd. Machine translation system
US5678039A (en) * 1994-09-30 1997-10-14 Borland International, Inc. System and methods for translating software into localized versions
US5696980A (en) * 1992-04-30 1997-12-09 Sharp Kabushiki Kaisha Machine translation system utilizing bilingual equivalence statements
US5768590A (en) * 1994-08-01 1998-06-16 Fujitsu Limited Program generating system for application-specific add-on boards using the language of individuals
US5774726A (en) * 1995-04-24 1998-06-30 Sun Microsystems, Inc. System for controlled generation of assembly language instructions using assembly language data types including instruction types in a computer language as input to compiler
US5794177A (en) * 1995-07-19 1998-08-11 Inso Corporation Method and apparatus for morphological analysis and generation of natural language text
US5930746A (en) * 1996-03-20 1999-07-27 The Government Of Singapore Parsing and translating natural language sentences automatically
US5963894A (en) * 1994-06-24 1999-10-05 Microsoft Corporation Method and system for bootstrapping statistical processing into a rule-based natural language parser
US5970490A (en) 1996-11-05 1999-10-19 Xerox Corporation Integration platform for heterogeneous databases
US6055365A (en) * 1996-11-08 2000-04-25 Sterling Software, Inc. Code point translation for computer text, using state tables
US6092036A (en) 1998-06-02 2000-07-18 Davox Corporation Multi-lingual data processing system and system and method for translating text used in computer software utilizing an embedded translator
US6092037A (en) * 1996-03-27 2000-07-18 Dell Usa, L.P. Dynamic multi-lingual software translation system
US6275978B1 (en) 1998-11-04 2001-08-14 Agilent Technologies, Inc. System and method for term localization differentiation using a resource bundle generator
US6278967B1 (en) 1992-08-31 2001-08-21 Logovista Corporation Automated system for generating natural language translations that are domain-specific, grammar rule-based, and/or based on part-of-speech analysis
US6393389B1 (en) * 1999-09-23 2002-05-21 Xerox Corporation Using ranked translation choices to obtain sequences indicating meaning of multi-token expressions
US6425119B1 (en) * 1996-10-09 2002-07-23 At&T Corp Method to produce application oriented languages
US6453464B1 (en) * 1998-09-03 2002-09-17 Legacyj. Corp., Inc. Method and apparatus for converting COBOL to Java
US20020156849A1 (en) * 1998-09-01 2002-10-24 Donoho David Leigh Method and apparatus for computed relevance messaging
US6492995B1 (en) 1999-04-26 2002-12-10 International Business Machines Corporation Method and system for enabling localization support on web applications
US20030066058A1 (en) * 2001-10-01 2003-04-03 Sun Microsystems, Inc. Language-sensitive whitespace adjustment in a software engineering tool
US20030106049A1 (en) * 2001-11-30 2003-06-05 Sun Microsystems, Inc. Modular parser architecture
US20030188293A1 (en) 2002-03-14 2003-10-02 Sun Microsystems, Inc. Method, system, and program for translating a class schema in a source language to a target language
US20040002848A1 (en) 2002-06-28 2004-01-01 Ming Zhou Example based machine translation system
US6675377B1 (en) * 1999-09-13 2004-01-06 Matsushita Electric Industrial Co., Ltd. Program conversion apparatus
US20040015889A1 (en) * 2001-03-26 2004-01-22 Todd Stephen J. Translator-compiler for converting legacy management software
US20040015834A1 (en) * 2000-12-20 2004-01-22 Lionel Mestre Method and apparatus for generating serialization code for representing a model in different type systems
US20040039809A1 (en) 2002-06-03 2004-02-26 Ranous Alexander Charles Network subscriber usage recording system
US20040078781A1 (en) 2002-10-16 2004-04-22 Novy Ronald Stephen Algorithm for creating and translating cross-platform compatible software
US6735759B1 (en) 1999-07-28 2004-05-11 International Business Machines Corporation Editing system for translating displayed user language using a wrapper class
US20040111713A1 (en) * 2002-12-06 2004-06-10 Rioux Christien R. Software analysis framework
US20040153435A1 (en) 2003-01-30 2004-08-05 Decode Genetics Ehf. Method and system for defining sets by querying relational data using a set definition language
US20040215441A1 (en) 2003-04-28 2004-10-28 Orofino Donald Paul Applying constraints to block diagram models
US20040243645A1 (en) 2003-05-30 2004-12-02 International Business Machines Corporation System, method and computer program product for performing unstructured information management and automatic text analysis, and providing multiple document views derived from different document tokenizations
US20040255279A1 (en) * 2003-04-22 2004-12-16 Alasdair Rawsthorne Block translation optimizations for program code conversation
US20050050030A1 (en) 2003-01-30 2005-03-03 Decode Genetics Ehf. Set definition language for relational data
US20050050526A1 (en) * 2003-08-28 2005-03-03 Dahne-Steuber Ines Antje System and method for real-time generation of software translation
US20050097514A1 (en) * 2003-05-06 2005-05-05 Andrew Nuss Polymorphic regular expressions
US6904563B2 (en) 2001-04-05 2005-06-07 International Business Machines Corporation Editing platforms for remote user interface translation
US20050125811A1 (en) * 2002-02-14 2005-06-09 Microsoft Corporation API schema language and transformation techniques
US6925597B2 (en) * 2000-04-14 2005-08-02 Picsel Technologies Limited Systems and methods for digital document processing
US6954746B1 (en) 2001-06-01 2005-10-11 Oracle International Corporation Block corruption analysis and fixing tool
US20050246696A1 (en) 2004-04-29 2005-11-03 International Business Machines Corporation Method and apparatus for hardware awareness of data types
US20050251706A1 (en) 2004-04-29 2005-11-10 International Business Machines Corporation Method and apparatus for data-aware hardware operations
US20050251707A1 (en) 2004-04-29 2005-11-10 International Business Machines Corporation Mothod and apparatus for implementing assertions in hardware
US20050257092A1 (en) 2004-04-29 2005-11-17 International Business Machines Corporation Method and apparatus for identifying access states for variables
US20050278270A1 (en) 2004-06-14 2005-12-15 Hewlett-Packard Development Company, L.P. Data services handler
US20060020946A1 (en) 2004-04-29 2006-01-26 International Business Machines Corporation Method and apparatus for data-aware hardware arithmetic
US6993473B2 (en) 2001-08-31 2006-01-31 Equality Translation Services Productivity tool for language translators
US20060041838A1 (en) 2004-08-23 2006-02-23 Sun Microsystems, Inc. System and method for automatically generating XML schema for validating XML input documents
US7031956B1 (en) 2000-02-16 2006-04-18 Verizon Laboratories Inc. System and method for synchronizing and/or updating an existing relational database with supplemental XML data
US20060167735A1 (en) 1999-10-25 2006-07-27 Ward Richard E Method and system for customer service process management
US20060174196A1 (en) 2005-01-28 2006-08-03 Oracle International Corporation Advanced translation context via web pages embedded with resource information
US20060206523A1 (en) 2005-03-14 2006-09-14 Microsoft Corporation Single-pass translation of flat-file documents into XML format including validation, ambiguity resolution, and acknowledgement generation
US20060235715A1 (en) 2005-01-14 2006-10-19 Abrams Carl E Sharable multi-tenant reference data utility and methods of operation of same
US20060235714A1 (en) 2005-01-14 2006-10-19 Adinolfi Ronald E Enabling flexible scalable delivery of on demand datasets
US20060235831A1 (en) 2005-01-14 2006-10-19 Adinolfi Ronald E Multi-source multi-tenant entitlement enforcing data repository and method of operation
US20060247944A1 (en) 2005-01-14 2006-11-02 Calusinski Edward P Jr Enabling value enhancement of reference data by employing scalable cleansing and evolutionarily tracked source data tags
US7146361B2 (en) 2003-05-30 2006-12-05 International Business Machines Corporation System, method and computer program product for performing unstructured information management and automatic text analysis, including a search operator functioning as a Weighted AND (WAND)
US20060288285A1 (en) 2003-11-21 2006-12-21 Lai Fon L Method and system for validating the content of technical documents
US20060287844A1 (en) 2005-06-15 2006-12-21 Xerox Corporation Method and system for improved software localization
US20070245321A1 (en) 2004-09-24 2007-10-18 University Of Abertay Dundee Computer games localisation
US20070250528A1 (en) * 2006-04-21 2007-10-25 Microsoft Corporation Methods for processing formatted data
US20070250821A1 (en) * 2006-04-21 2007-10-25 Microsoft Corporation Machine declarative language for formatted data processing
US20080177640A1 (en) 2005-05-09 2008-07-24 Salih Burak Gokturk System and method for using image analysis and search in e-commerce
US7516229B2 (en) 2002-11-18 2009-04-07 Hewlett-Packard Development Company, L.P. Method and system for integrating interaction protocols between two entities
Patent Citations (79)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5263162A (en) * 1990-11-07 1993-11-16 Hewlett-Packard Company Method of validating a label translation configuration by parsing a real expression describing the translation configuration
US5251130A (en) 1991-04-18 1993-10-05 International Business Machines Corporation Method and apparatus for facilitating contextual language translation within an interactive software application
US5442546A (en) * 1991-11-29 1995-08-15 Hitachi, Ltd. System and method for automatically generating translation templates from a pair of bilingual sentences
US5696980A (en) * 1992-04-30 1997-12-09 Sharp Kabushiki Kaisha Machine translation system utilizing bilingual equivalence statements
US5475586A (en) * 1992-05-08 1995-12-12 Sharp Kabushiki Kaisha Translation apparatus which uses idioms with a fixed and variable portion where a variable portion is symbolic of a group of words
US6278967B1 (en) 1992-08-31 2001-08-21 Logovista Corporation Automated system for generating natural language translations that are domain-specific, grammar rule-based, and/or based on part-of-speech analysis
US5646840A (en) * 1992-11-09 1997-07-08 Ricoh Company, Ltd. Language conversion system and text creating system using such
US5579223A (en) * 1992-12-24 1996-11-26 Microsoft Corporation Method and system for incorporating modifications made to a computer program into a translated version of the computer program
US5659765A (en) * 1994-03-15 1997-08-19 Toppan Printing Co., Ltd. Machine translation system
US5644774A (en) * 1994-04-27 1997-07-01 Sharp Kabushiki Kaisha Machine translation system having idiom processing function
US5963894A (en) * 1994-06-24 1999-10-05 Microsoft Corporation Method and system for bootstrapping statistical processing into a rule-based natural language parser
US5768590A (en) * 1994-08-01 1998-06-16 Fujitsu Limited Program generating system for application-specific add-on boards using the language of individuals
US5644775A (en) * 1994-08-11 1997-07-01 International Business Machines Corporation Method and system for facilitating language translation using string-formatting libraries
US5678039A (en) * 1994-09-30 1997-10-14 Borland International, Inc. System and methods for translating software into localized versions
US5774726A (en) * 1995-04-24 1998-06-30 Sun Microsystems, Inc. System for controlled generation of assembly language instructions using assembly language data types including instruction types in a computer language as input to compiler
US5794177A (en) * 1995-07-19 1998-08-11 Inso Corporation Method and apparatus for morphological analysis and generation of natural language text
US5930746A (en) * 1996-03-20 1999-07-27 The Government Of Singapore Parsing and translating natural language sentences automatically
US6092037A (en) * 1996-03-27 2000-07-18 Dell Usa, L.P. Dynamic multi-lingual software translation system
US6425119B1 (en) * 1996-10-09 2002-07-23 At&T Corp Method to produce application oriented languages
US5970490A (en) 1996-11-05 1999-10-19 Xerox Corporation Integration platform for heterogeneous databases
US6055365A (en) * 1996-11-08 2000-04-25 Sterling Software, Inc. Code point translation for computer text, using state tables
US6092036A (en) 1998-06-02 2000-07-18 Davox Corporation Multi-lingual data processing system and system and method for translating text used in computer software utilizing an embedded translator
US20020156849A1 (en) * 1998-09-01 2002-10-24 Donoho David Leigh Method and apparatus for computed relevance messaging
US6453464B1 (en) * 1998-09-03 2002-09-17 Legacyj. Corp., Inc. Method and apparatus for converting COBOL to Java
US6275978B1 (en) 1998-11-04 2001-08-14 Agilent Technologies, Inc. System and method for term localization differentiation using a resource bundle generator
US6492995B1 (en) 1999-04-26 2002-12-10 International Business Machines Corporation Method and system for enabling localization support on web applications
US6735759B1 (en) 1999-07-28 2004-05-11 International Business Machines Corporation Editing system for translating displayed user language using a wrapper class
US6675377B1 (en) * 1999-09-13 2004-01-06 Matsushita Electric Industrial Co., Ltd. Program conversion apparatus
US6393389B1 (en) * 1999-09-23 2002-05-21 Xerox Corporation Using ranked translation choices to obtain sequences indicating meaning of multi-token expressions
US20060167735A1 (en) 1999-10-25 2006-07-27 Ward Richard E Method and system for customer service process management
US7031956B1 (en) 2000-02-16 2006-04-18 Verizon Laboratories Inc. System and method for synchronizing and/or updating an existing relational database with supplemental XML data
US6925597B2 (en) * 2000-04-14 2005-08-02 Picsel Technologies Limited Systems and methods for digital document processing
US20040015834A1 (en) * 2000-12-20 2004-01-22 Lionel Mestre Method and apparatus for generating serialization code for representing a model in different type systems
US20040015889A1 (en) * 2001-03-26 2004-01-22 Todd Stephen J. Translator-compiler for converting legacy management software
US6904563B2 (en) 2001-04-05 2005-06-07 International Business Machines Corporation Editing platforms for remote user interface translation
US6954746B1 (en) 2001-06-01 2005-10-11 Oracle International Corporation Block corruption analysis and fixing tool
US6993473B2 (en) 2001-08-31 2006-01-31 Equality Translation Services Productivity tool for language translators
US20030066058A1 (en) * 2001-10-01 2003-04-03 Sun Microsystems, Inc. Language-sensitive whitespace adjustment in a software engineering tool
US20030106049A1 (en) * 2001-11-30 2003-06-05 Sun Microsystems, Inc. Modular parser architecture
US20050125811A1 (en) * 2002-02-14 2005-06-09 Microsoft Corporation API schema language and transformation techniques
US20030188293A1 (en) 2002-03-14 2003-10-02 Sun Microsystems, Inc. Method, system, and program for translating a class schema in a source language to a target language
US20040039809A1 (en) 2002-06-03 2004-02-26 Ranous Alexander Charles Network subscriber usage recording system
US7353165B2 (en) 2002-06-28 2008-04-01 Microsoft Corporation Example based machine translation system
US20040002848A1 (en) 2002-06-28 2004-01-01 Ming Zhou Example based machine translation system
US20040078781A1 (en) 2002-10-16 2004-04-22 Novy Ronald Stephen Algorithm for creating and translating cross-platform compatible software
US7516229B2 (en) 2002-11-18 2009-04-07 Hewlett-Packard Development Company, L.P. Method and system for integrating interaction protocols between two entities
US20040111713A1 (en) * 2002-12-06 2004-06-10 Rioux Christien R. Software analysis framework
US20040153435A1 (en) 2003-01-30 2004-08-05 Decode Genetics Ehf. Method and system for defining sets by querying relational data using a set definition language
US20050050030A1 (en) 2003-01-30 2005-03-03 Decode Genetics Ehf. Set definition language for relational data
US20040255279A1 (en) * 2003-04-22 2004-12-16 Alasdair Rawsthorne Block translation optimizations for program code conversation
US20040215441A1 (en) 2003-04-28 2004-10-28 Orofino Donald Paul Applying constraints to block diagram models
US20050097514A1 (en) * 2003-05-06 2005-05-05 Andrew Nuss Polymorphic regular expressions
US20070112763A1 (en) 2003-05-30 2007-05-17 International Business Machines Corporation System, method and computer program product for performing unstructured information management and automatic text analysis, including a search operator functioning as a weighted and (WAND)
US7146361B2 (en) 2003-05-30 2006-12-05 International Business Machines Corporation System, method and computer program product for performing unstructured information management and automatic text analysis, including a search operator functioning as a Weighted AND (WAND)
US20040243645A1 (en) 2003-05-30 2004-12-02 International Business Machines Corporation System, method and computer program product for performing unstructured information management and automatic text analysis, and providing multiple document views derived from different document tokenizations
US20050050526A1 (en) * 2003-08-28 2005-03-03 Dahne-Steuber Ines Antje System and method for real-time generation of software translation
US20060288285A1 (en) 2003-11-21 2006-12-21 Lai Fon L Method and system for validating the content of technical documents
US7386690B2 (en) 2004-04-29 2008-06-10 International Business Machines Corporation Method and apparatus for hardware awareness of data types
US20050257092A1 (en) 2004-04-29 2005-11-17 International Business Machines Corporation Method and apparatus for identifying access states for variables
US7328374B2 (en) 2004-04-29 2008-02-05 International Business Machines Corporation Method and apparatus for implementing assertions in hardware
US20050251707A1 (en) 2004-04-29 2005-11-10 International Business Machines Corporation Mothod and apparatus for implementing assertions in hardware
US20050251706A1 (en) 2004-04-29 2005-11-10 International Business Machines Corporation Method and apparatus for data-aware hardware operations
US20050246696A1 (en) 2004-04-29 2005-11-03 International Business Machines Corporation Method and apparatus for hardware awareness of data types
US20060020946A1 (en) 2004-04-29 2006-01-26 International Business Machines Corporation Method and apparatus for data-aware hardware arithmetic
US7269718B2 (en) 2004-04-29 2007-09-11 International Business Machines Corporation Method and apparatus for verifying data types to be used for instructions and casting data types if needed
US7313575B2 (en) 2004-06-14 2007-12-25 Hewlett-Packard Development Company, L.P. Data services handler
US20050278270A1 (en) 2004-06-14 2005-12-15 Hewlett-Packard Development Company, L.P. Data services handler
US20060041838A1 (en) 2004-08-23 2006-02-23 Sun Microsystems, Inc. System and method for automatically generating XML schema for validating XML input documents
US20070245321A1 (en) 2004-09-24 2007-10-18 University Of Abertay Dundee Computer games localisation
US20060235831A1 (en) 2005-01-14 2006-10-19 Adinolfi Ronald E Multi-source multi-tenant entitlement enforcing data repository and method of operation
US20060235714A1 (en) 2005-01-14 2006-10-19 Adinolfi Ronald E Enabling flexible scalable delivery of on demand datasets
US20060247944A1 (en) 2005-01-14 2006-11-02 Calusinski Edward P Jr Enabling value enhancement of reference data by employing scalable cleansing and evolutionarily tracked source data tags
US20060235715A1 (en) 2005-01-14 2006-10-19 Abrams Carl E Sharable multi-tenant reference data utility and methods of operation of same
US20060174196A1 (en) 2005-01-28 2006-08-03 Oracle International Corporation Advanced translation context via web pages embedded with resource information
US20060206523A1 (en) 2005-03-14 2006-09-14 Microsoft Corporation Single-pass translation of flat-file documents into XML format including validation, ambiguity resolution, and acknowledgement generation
US20080177640A1 (en) 2005-05-09 2008-07-24 Salih Burak Gokturk System and method for using image analysis and search in e-commerce
US20060287844A1 (en) 2005-06-15 2006-12-21 Xerox Corporation Method and system for improved software localization
US20070250528A1 (en) * 2006-04-21 2007-10-25 Microsoft Corporation Methods for processing formatted data
US20070250821A1 (en) * 2006-04-21 2007-10-25 Microsoft Corporation Machine declarative language for formatted data processing
Non-Patent Citations (17)
* Cited by examiner, † Cited by third party
Title
"String and Regular Expression methods," JavaScript Kit, Jan. 31, 2001, pp. 1-2. *
"String and Regular Expression methods," JavaScript Kit, Jan. 31, 2001, <http://www.javascriptkit.com/javatutors/re3.shtml> pp. 1-2. *
Brown, P., et al., "The Mathematics of Statistical Machine Translation: Parameter Estimation," Computational Linguistics 19(2):263-311, 1993.
Chalupsky, H., "Ontomorph: A Translation System for Symbolic Knowledge," in A. Cohn et al. (eds.), Proceedings of the 7th International Conference on Principles of Knowledge Representation and Reasoning, Morgan Kaufman, San Francisco, Calif., 2000, pp. 471-482.
Chen, F., "Aligning Sentences in Bilingual Corpora Using Lexical Information," Proceedings of the 31st Annual Meeting of the Association for Computational Linguistics, Columbus, Ohio, Jun. 22-26, 1993.
Krauskopf, Curtis. "Using-FILE-and-LINE-to Reprot Errors" The Database Managers Inc. May 2005 . *
Krauskopf, Curtis. "Using—FILE—and—LINE—to Reprot Errors" The Database Managers Inc. May 2005 <http://www.decompile.com/cpp/faq/file—and—line—error—string.htm>. *
L-Soft Sweden AB, LISTSERV® Maestro, Version 1.2: Translating the LISTSERV Maestro User Interface, Mar. 18, 2004 11:10 am, 29 pages.
Michael Collins et al. "Clause Restructuring for Statistical Machine Translation." Association for Comutational Linguistics. 2005. pp. 1-10. *
Michael Collins et al. "Clause Restructuring for Statistical Machine Translation." Association for Comutational Linguistics. 2005. <http://delivery.acm.org/10.1145/1220000/1219906/p531-collins.pdf> pp. 1-10. *
M-Tech Information Technology, Inc., 10.19 Adding password strength rules, 2004 5 pages.
Rintanen and Zetzsche, Integrating Translation Tools in Document Creation, International Writers' Group, LLC, MultiLingual Press, reprinted with permission of translationzone.com, 1999-2005, 5 pages, www.internationalwriters.com/dejavu/Integrating-tools.html.
Rintanen and Zetzsche, Integrating Translation Tools in Document Creation, International Writers' Group, LLC, MultiLingual Press, reprinted with permission of translationzone.com, 1999-2005, 5 pages, www.internationalwriters.com/dejavu/Integrating—tools.html.
Schildhauer, E., Integrating Localization Processes With Software Development, Localization Reader 2004-2005, Localisation Research Centre, Department of Computer Science and Information Systems, University of Limerick, Ireland and MultiLingual Computing 2004, p. 106.
Terence Lewis, "Machine Translation: Boundaries and Practice in the Late '90s," IEEE, Feb 1997, pp. 1-5. *
Terence Lewis, "Machine Translation: Boundaries and Practice in the Late '90s," IEEE, Feb 1997, <http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=598659> pp. 1-5. *
The Open Group, Regular Expressions, The Single UNIX® Specification, Version 2, 1997, 16 pages.
Cited By (3)
* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8549492B2 (en) 2006-04-21 2013-10-01 Microsoft Corporation Machine declarative language for formatted data processing
US20140282439A1 (en) * 2013-03-14 2014-09-18 Red Hat, Inc. Migration assistance using compiler metadata
US9223570B2 (en) * 2013-03-14 2015-12-29 Red Hat, Inc. Migration assistance using compiler metadata
Also Published As
Publication number Publication date Type
US20070250811A1 (en) 2007-10-25 application
Similar Documents
Publication Publication Date Title
Odersky et al. The Scala language specification
Caprile et al. Restructuring Program Identifier Names.
Roy et al. Comparison and evaluation of code clone detection techniques and tools: A qualitative approach
Reps et al. The synthesizer generator: a system for constructing language-based editors
US6799718B2 (en) Development assistance for mixed-language sources
US5900004A (en) Method and system for interactive formatting of word processing documents with deferred rule evaluation and format editing
US5612872A (en) Machine translation system
US5673390A (en) Method and system for displaying error messages
Jones Haskell 98 language and libraries: the revised report
Flanagan JavaScript: The definitive guide: Activate your web pages
US20040260940A1 (en) Method and system for detecting vulnerabilities in source code
Marlow Haskell 2010 language report
US5754737A (en) System for supporting interactive text correction and user guidance features
US20040205605A1 (en) Method and system for stylesheet rule creation, combination, and removal
Heidorn Intelligent writing assistance
US20100242028A1 (en) System and method for performing code provenance review in a software due diligence system
US5371747A (en) Debugger program which includes correlation of computer program source code with optimized object code
US20080281580A1 (en) Dynamic parser
US20060287844A1 (en) Method and system for improved software localization
US7958493B2 (en) Type inference system and method
US20100146491A1 (en) System for Preparing Software Documentation in Natural Languages
US5857212A (en) System and method for horizontal alignment of tokens in a structural representation program editor
US20050010806A1 (en) Method and system for detecting privilege escalation vulnerabilities in source code
US5737608A (en) Per-keystroke incremental lexing using a conventional batch lexer
US20060285746A1 (en) Computer assisted document analysis
Legal Events
Date Code Title Description
AS Assignment
Owner name: MICROSOFT CORPORATION, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:AHS, DAVID;MOLA MARTI, JORDI;REEL/FRAME:017749/0676
Effective date: 20060419
AS Assignment
Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MICROSOFT CORPORATION;REEL/FRAME:034542/0001
Effective date: 20141014
FPAY Fee payment
Year of fee payment: 4
|
__label__pos
| 0.548444 |
WindowsSdk
monitor_status interface
• Definition：
int _stdcall monitor_status(int camera, const char * content, unsigned int content_len, DWORD wait_time);
• Parameter：
camera:[in]，The camera's handle which is from new_camera
content:[in]，One or more camera status which want to monitor
content_len:[in]，The monitor content's length
wait_time:[in]，The time waiting for repone, millisecond
• Return：
Return ERROR_OK if success，else refer to the definition of error number
• Explain：
Request monitor the state of the camera.
Before calling this function, should first ensure the connection of camera
with the specified has been established, or the operation will fail.
This function is one or more state request monitor camera to camera,
the result of the operation through the MONITOR_STATUS_RESULT event notification user.
When the operation is successful, if a user specified monitor changes, camera will notify the client program.
After receiving the rc_ipcam library can stimulate the MONITORED_STATUS_CHANGED event to notify the user.
For example, a user can request to monitor camera disk, record, alarm,
So once the camera disk or tape or alarm status changes,
The user can through paying attention to the camera MONITORED_STATUS_CHANGED event to get.
The content parameter is used to specify the name of the state to monitor.
The format of the content parameter is composed of one or more strings,
Each string is composed to monitor the state name, between each string '\0' separated by.
The content_len parameter value is equal to the length of all the data of content, including each end of the string '\0'.
Content = "disk\0record\0alarm\0"; (Note: Here "" does not mean that the content of C string, just represent the distribution in memory)
Content_len 18.
As for the specific state of camera please refer to the relevant CGI application guide.
IP Camera Windows SDK manual
Copyright：Shenzhen XRC Tech Co.,Ltd.
ICP：粤ICP备09050685号
|
__label__pos
| 0.577041 |
2
$\begingroup$
Definitions and notations.
Let $\mathcal{P}(X)$ the power set of $X$.
Let $\tau_X\subseteq\mathcal{P}(X)$ a topology on X.
We call $A$ irreducible if every time $A=B\cup C$ with $B,C$ closed set then $(B=A)\vee(C=A)$.
We call $X$ sober if every non empty irreducible closed set is the closure of a (single one) point.
We Call $K$ compact if every open covering $(U_i)_{i\in I}\subseteq\tau_X$ of $K$ (i.e. $K\subseteq\bigcup_{i\in I}U_i$) admits a finite subcovering of $K$ (i.e. there is a finite $J\subseteq I$ s.t. $K\subseteq\bigcup_{j\in J}U_j$). Note that $(X,\tau_X)$ is not required to be T$_2$.
We call $A$ relatively compact in $B$ if $A\subseteq B$ and every open covering of $B$ admits a finite subcovering of $A$. Write $A\ll B$ if $A$ is relatively compact in $B$ (note: by definitions $A$ is compact iff $A\ll A$).
We say that $F$ has the relatively compactness property if for all $A\in F$ exist $B\in F$ s.t. $B\ll A$.
We call $D\subseteq\mathcal{P}(X)$ direct if $D\neq\emptyset$ and for all $A,B\in D$ exist $C\in D$ s.t. $A\cup B\subseteq C$. In such case we call $C$ an upper bound of $\{A,B\}$. In other words $D$ is directed if it is non empty and closed by upper bounds of his finite subsets.
We call supremum of $A\subseteq\mathcal{P}(X)$ the lower upper bound (by inclusion) of $A$, i.e. $S$ is a supremum of $A$ if for all $B\in A$ we have $B\subseteq S$ and $S$ is a subset of all other sets with the same property. (note: if it exists, there is at most one supremum).
We call $S\subseteq \mathcal{P}(X)$ scott open if $S$ is upward closed and every time it contains the supremum of a direct set $D$ then $S\cap D\neq\emptyset$.
We call $F\subset\mathcal{P}(X)$ a filter if $\emptyset\notin F$, it is an upward set (i.e. if $A\in F$ and $A\subseteq B$ then $B\in F$) and it is closed by finite intersections.
We call $\mathcal{Ofilt}(X)$ the space of the scott open filters on $X$.
We call $A\subseteq X$ saturated if $A=\bigcap\{U\in\tau_X\mid A\subseteq U\}$.
We call $\mathcal{Q}(X)\subseteq\mathcal{P}(X)$ the set of all saturated and compact subset of $X$.
The claim.
Let $(X,\tau_X)$ a sober (and second countable) space. Then
$\begin{align} f\colon\mathcal{Q}(X)&\to\mathcal{Ofilt}(\tau_X)\\ Q&\mapsto f(Q)=\{U\in\tau_X\mid Q\subset U\}, \end{align}$
is a bijective function whose inverse is the map which associates to a scott open filter in $\tau_X$ the intersection of the filter.
Note: we’ve put between brackets the assumption for X to be second countable because, for our purpose, we have it. In any case the proposition seems to be true without that assumption, as is shown in the Theorem 2.16 of [1]
My question, some explanations and some requests.
I'm able to prove that the function $f$ is well defined and injective. On the other hand the proof that the intersection of such a filter is compact (it is obviously a saturated set) is really an hard problem for me.
If it is possible I’m looking for a self-cotained (maybe direct) proof: I lost myself in cross-references from an article to another in which the authors refer.
What follows is my steps (without the final one).
Beginning of (my) proof.
Note: I'm supposing that X is second countable.
Let $F$ be a scott open filter of $\tau_X$ and let $P=\bigcap F$.
Let $(V_n)_{n\in\omega}$ be a arbitrary open covering of $P$ (eventually with repetitions). We have to prove that it has a finite subcovering of $P$ (we can suppose the covering to be countable because we have supposed $X$ is second countable).
Let $W_k=\bigcap_{n≤k}V_n$, so for any $k\in\omega$ we have $W_k\subseteq W_{k+1}$ and $P\subset\bigcup_{k\in\omega}W_k$. We note that $\{W_k\mid k\in\omega\}$ form a direct set and that $\bigcup_{k\in\omega}W_k$, his supremum, is open. So if we prove that $\bigcup_{k\in\omega}W_k\in F$ we can conclude thanks to the scott openness and because each $W_k$ is a finite union, covering $P$, of some sets in $(V_n)_{n\in\omega}$ sequence.
On the other hand, if we suppose that we have proved the statement, then the intersection of the filter (i.e. $P$) is in $\mathcal{Q}(X)$ and by $f$ it would be mapped back again to $F$ (thanks to the injectivity). So, if the statement is true, $F$ contains all open set containing $P$.
If we are able to prove that a general open set containing $P$ is in $F$ (that we know is consistent and "true"...), then we'll conclude that $\bigcup_{k\in\omega}W_k\in F$ (because it is open) and so we'll conclude the proof.
So, let $A\in\tau_X$ an open set of $X$ containing $P$.
First of all if $P\in F$ then $A\in F$ (because $F$ is a filter).
So we suppose $P\notin F$. Then (only by second countability) we can take a decrescent (by inclusion) sequence $(U_n)_{n\in\omega}\subseteq F$ s.t. $\bigcap_{n\in\omega}U_n=P$.
On the first hand if exist $m\in\omega$ s.t. $U_m\subseteq A$ then $A\in F$ (because $F$ is a filter) so we can suppose that for all $n\in\omega$ we have $U_n\setminus A\neq\emptyset$.
So let $C_n=U_n\setminus A\neq\emptyset$ and let $C=\bigcap_{n\in\omega}C_n$. There are only two cases: $C\neq\emptyset$ or $C=\emptyset$.
If $C\neq\emptyset$ then (because of $C\subseteq\bigcap_{n\in\omega}U_n=P$) we conclude an absurd, i.e. $C\subseteq P\subseteq A$ when $C$ does not contain any points of $A$; so it must be $C=\emptyset$ and so...
Step-conclusion.
With regard to the proof of the statement I'm not able to go on from what I did in the last section; but I'm sure that without the assumption of scott openness the theorem is false.
we give a counterexample: let $X=\mathbb{R}$, $\tau_\mathbb{R}="\text{standard topology generated by the open intervals}"$, $P=\mathbb{Z}$, $F=\{A\in\tau_\mathbb{R}\mid \mathbb{Z}\subseteq A\}$; then let $\{\bigcup_{z\in\mathbb{Z}}(a_z,b_z)\mid\forall z\in\mathbb{Z}\; a_z,b_z\in\mathbb{Q}\wedge z\in(a_z,b_z)\}\subseteq F$ be the sequence of "$(U_n)_{n\in\omega}$", decrescent by inclusion, whose intersection is $P$.
So,
$\mathbb{R}$ is sober and second countable;
$F$ is the filter of all open set containing $P$ (but F is not scott open, e.g. $((-n,n))_{n\in\omega}$ is clearly a direct sequence whose union is $\mathbb{R}\in F$ but for all $n\in\omega$ we have $(-n,n)\notin F$);
the intersection of $F$ is $P$ but $P$ is clearly not compact, e.g. $\{(z-\frac{1}{2},z+\frac{1}{2})\mid z\in\mathbb{Z}\}$ is clearly a covering of $\mathbb{Z}$ without a finite sub covering.
Moreover.
I'm aware that the guideline of the proof that I followed cannot be applied in the general setting (without second countably hypothesis on $X$)...but I'm not in the general case and I'm looking for a "simple", direct and clear proof (if it exist).
In a little more specific setting (which is my case) we don't require directly that $F$ is scott open but that it respects the relatively compactness property, which implies the scott openness for $F$.
Indeed, if $D$ is a direct subset of $\mathcal{P}(\tau_X)$ whose supremum $S$ (i.e. $S=\bigcup D$) lies on $F$ (so $D$ is a covering of $S$), then there exists $A\in F$ with $A\ll S$, i.e. there must be a finite subset of $D$ that covers a set $A$ who lies on $F$ and so the union of $D$ must lie on $F$ too (because $F$ is a filter). To conclude we have only to note that a finite union of elements of a direct set lies on the direct set (by definition of direct set) and so our union is in $D$. Then $D\cap F\neq\emptyset$ and so $F$ is scott open.
Note that in my counterexample, obviously, $F$ fails this property too...
In any case if you use the relatively compactness instead of the scott openness to find a (simpler) proof... it will be fine for me!
Thank you all,
Corrado.
References.
[1]: Karl Heinrich Hofmann and Michael William Mislove. Local compactness and continuous lattices. In Bernhard Banaschewski and Rudolf-Eberhard Hoffmann, editors, Continuous Lattices, volume 871 of Lecture Notes in Mathematics, pages 209–248. Springer Berlin Heidelberg, 1981 (Theorem 2.16 pag. 226)
see also (if interested on my specific setting)
[2]: Matthew de Brecht. Quasi-polish spaces. Annals of Pure and Applied Logic, (164):356–381, 2013. (last three lines of the proof of the Theorem 44 pag. 369)
$\endgroup$
2
$\begingroup$
A self-contained proof is in the book "Continuous lattices and domains" by G. Gierz, K. H. Hofmann, K. Keimel, J. D. Lawson, M. W. Mislove and D. S. Scott.
The particular place you need is Lemma II-1.19 on page 146.
$\endgroup$
• $\begingroup$ Thank you very much, I have that book and I've found that lemma! Great. This evening I'll report here the proof. $\endgroup$ – Corrado Jul 26 '14 at 18:05
2
$\begingroup$
We have (only) to prove that for every open set $A\supseteq P$, where $P=\bigcap F$, we have $A\in F$ (for the whole notation you can see the question).
The missing step.
(we refer to [3], thanks to the suggestion of მამუკა ჯიბლაძე)
Suppose $P\subseteq A\notin F$ then (since $X\in F$) there must exist $V\in\tau_X$ s.t. $A\subseteq V\notin F$ with $T\in F$ for every open set $T\supseteq V$, i.e. $V$ is the maximal open set containing $A$ with respect to not being in $F$.
So if $B,C\in\tau$ s.t. $B\cap C=V$ then $(B=V) \vee (C=V)$ or $V\in F$ because $F$ is a filter.
Then $X\setminus V$ is a closed (obviously) and irreducible set, indeed if $C_1,C_2\subsetneq(X\setminus V)$ are two closed sets s.t. $C_1\cup C_2=(X\setminus V)$ then $(X\setminus C_1)\cap(X\setminus C_2)=V$ but $(X\setminus C_1)\supsetneq V \wedge (X\setminus C_2)\supsetneq V$, absurd.
Thanks to sobriety, there exists $p\in X$ s.t. $\overline{\{p\}}=X\setminus V$.
Now, for all $G\in F$ we have $p\in G$, because if $p\notin G$ then $\overline{\{p\}}\cap G=(X \setminus V)\cap G=\emptyset$ and so $G\subseteq V$ and $V\in F$, because $F$ is a filter; abusurd.
So, for all $G\in F$ we have $p\in G$ but this means that $p\in P$ and then $p\in A\subseteq V=(X\setminus\overline{\{p\}})$, absurd.
So $A\in F.\quad\square$
The existence of V
Let $D=\{E\in(\tau_X\setminus F)\mid A\subseteq E\}$ ordered by inclusion. So D is a poset. Let $M$ the lower upper bound of a generical chain in $D$, i.e. $M$ is the union of the chain. If $M\in F$ so, thanks to the Scott openness of $F$, there must be an element of the chain which lies in $F$, absurd.
So, the lower upper bound of every chain in $D$ lies in $D$. By Zorn's lemma there is a maximal element in $D$. Call one of them $V$.
Reference.
[3]: G. Gierz, K. H. Hofmann, K. Keimel, J. D. Lawson, M. W. Mislove and D. S. Scott. Continuous lattices and domains (Lemma II-1.19, page 146).
$\endgroup$
• $\begingroup$ Fine, except existence of a maximal $V$ in the very beginning needs some justification and depends on openness of $F$. In Lemma II-1.19 in this place they erroneously refer to I-3.12 - actually they should refer to I-3.4; whereas I-3.12 is needed for the subsequent argument about irreducibility... $\endgroup$ – მამუკა ჯიბლაძე Jul 27 '14 at 16:42
• $\begingroup$ Thanks @მამუკაჯიბლაძე, one more time. I add the proof of existence of $V$. $\endgroup$ – Corrado Jul 29 '14 at 12:18
Your Answer
By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.
Not the answer you're looking for? Browse other questions tagged or ask your own question.
|
__label__pos
| 0.866482 |
rculfhash: update comments in implementation
[urcu.git] / urcu / rculfhash.h
CommitLineData
a42cc659
MD
1#ifndef _URCU_RCULFHASH_H
2#define _URCU_RCULFHASH_H
ab7d5fc6 3
f0c29ed7
MD
4/*
5 * urcu/rculfhash.h
6 *
7 * Userspace RCU library - Lock-Free RCU Hash Table
8 *
9 * Copyright 2011 - Mathieu Desnoyers <[email protected]>
0dcf4847 10 * Copyright 2011 - Lai Jiangshan <[email protected]>
f0c29ed7
MD
11 *
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
cf77d1fa
MD
25 *
26 * Include this file _after_ including your URCU flavor.
f0c29ed7
MD
27 */
28
674f7a69 29#include <stdint.h>
6d320126 30#include <urcu/compiler.h>
abc490a1 31#include <urcu-call-rcu.h>
7b17c13e 32#include <urcu-flavor.h>
abc490a1 33
01389791
MD
34#ifdef __cplusplus
35extern "C" {
36#endif
37
7f52427b 38/*
04db56f8 39 * cds_lfht_node: Contains the next pointers and reverse-hash
7f52427b 40 * value required for lookup and traversal of the hash table.
04db56f8 41 *
db00ccc3 42 * struct cds_lfht_node should be aligned on 8-bytes boundaries because
13f656f9
MD
43 * the three lower bits are used as flags. It is worth noting that the
44 * information contained within these three bits could be represented on
45 * two bits by re-using the same bit for REMOVAL_OWNER_FLAG and
46 * BUCKET_FLAG. This can be done if we ensure that no iterator nor
47 * updater check the BUCKET_FLAG after it detects that the REMOVED_FLAG
48 * is set. Given the minimum size of struct cds_lfht_node is 8 bytes on
49 * 32-bit architectures, we choose to go for simplicity and reserve
50 * three bits.
7f52427b 51 *
ae62aa6a
MD
52 * struct cds_lfht_node can be embedded into a structure (as a field).
53 * caa_container_of() can be used to get the structure from the struct
54 * cds_lfht_node after a lookup.
04db56f8
LJ
55 *
56 * The structure which embeds it typically holds the key (or key-value
57 * pair) of the object. The caller code is responsible for calculation
58 * of the hash value for cds_lfht APIs.
ae62aa6a 59 */
14044b37 60struct cds_lfht_node {
3f2f3714 61 struct cds_lfht_node *next; /* ptr | REMOVAL_OWNER_FLAG | BUCKET_FLAG | REMOVED_FLAG */
04db56f8 62 unsigned long reverse_hash;
db00ccc3 63} __attribute__((aligned(8)));
abc490a1 64
7f52427b 65/* cds_lfht_iter: Used to track state while traversing a hash chain. */
adc0de68
MD
66struct cds_lfht_iter {
67 struct cds_lfht_node *node, *next;
68};
69
70static inline
71struct cds_lfht_node *cds_lfht_iter_get_node(struct cds_lfht_iter *iter)
72{
73 return iter->node;
74}
75
14044b37 76struct cds_lfht;
ab7d5fc6 77
5e28c532
MD
78/*
79 * Caution !
abc490a1 80 * Ensure reader and writer threads are registered as urcu readers.
5e28c532
MD
81 */
82
996ff57c 83typedef int (*cds_lfht_match_fct)(struct cds_lfht_node *node, const void *key);
abc490a1 84
f0c29ed7 85/*
14044b37 86 * cds_lfht_node_init - initialize a hash table node
0422d92c 87 * @node: the node to initialize.
04db56f8
LJ
88 *
89 * This function is kept to be eventually used for debugging purposes
90 * (detection of memory corruption).
f0c29ed7 91 */
abc490a1 92static inline
04db56f8 93void cds_lfht_node_init(struct cds_lfht_node *node)
abc490a1 94{
abc490a1 95}
674f7a69 96
b8af5011
MD
97/*
98 * Hash table creation flags.
99 */
100enum {
101 CDS_LFHT_AUTO_RESIZE = (1U << 0),
5afadd12 102 CDS_LFHT_ACCOUNTING = (1U << 1),
b8af5011
MD
103};
104
0b6aa001
LJ
105struct cds_lfht_mm_type {
106 struct cds_lfht *(*alloc_cds_lfht)(unsigned long min_nr_alloc_buckets,
107 unsigned long max_nr_buckets);
108 void (*alloc_bucket_table)(struct cds_lfht *ht, unsigned long order);
109 void (*free_bucket_table)(struct cds_lfht *ht, unsigned long order);
110 struct cds_lfht_node *(*bucket_at)(struct cds_lfht *ht,
111 unsigned long index);
112};
113
114extern const struct cds_lfht_mm_type cds_lfht_mm_order;
308d1cb3 115extern const struct cds_lfht_mm_type cds_lfht_mm_chunk;
b0b55251 116extern const struct cds_lfht_mm_type cds_lfht_mm_mmap;
0b6aa001 117
674f7a69 118/*
7a9dcf9b 119 * _cds_lfht_new - API used by cds_lfht_new wrapper. Do not use directly.
674f7a69 120 */
0422d92c 121struct cds_lfht *_cds_lfht_new(unsigned long init_size,
0722081a 122 unsigned long min_nr_alloc_buckets,
747d725c 123 unsigned long max_nr_buckets,
b8af5011 124 int flags,
0b6aa001 125 const struct cds_lfht_mm_type *mm,
7b17c13e 126 const struct rcu_flavor_struct *flavor,
b7d619b0 127 pthread_attr_t *attr);
ab7d5fc6 128
7a9dcf9b
MD
129/*
130 * cds_lfht_new - allocate a hash table.
747d725c
LJ
131 * @init_size: number of buckets to allocate initially. Must be power of two.
132 * @min_nr_alloc_buckets: the minimum number of allocated buckets.
133 * (must be power of two)
134 * @max_nr_buckets: the maximum number of hash table buckets allowed.
135 * (must be power of two)
f22dd01d
MD
136 * @flags: hash table creation flags (can be combined with bitwise or: '|').
137 * 0: no flags.
138 * CDS_LFHT_AUTO_RESIZE: automatically resize hash table.
44bbe7fa
LJ
139 * CDS_LFHT_ACCOUNTING: count the number of node addition
140 * and removal in the table
b7d619b0 141 * @attr: optional resize worker thread attributes. NULL for default.
7a9dcf9b 142 *
7a9dcf9b
MD
143 * Return NULL on error.
144 * Note: the RCU flavor must be already included before the hash table header.
b7d619b0
MD
145 *
146 * The programmer is responsible for ensuring that resize operation has a
147 * priority equal to hash table updater threads. It should be performed by
148 * specifying the appropriate priority in the pthread "attr" argument, and,
149 * for CDS_LFHT_AUTO_RESIZE, by ensuring that call_rcu worker threads also have
150 * this priority level. Having lower priority for call_rcu and resize threads
151 * does not pose any correctness issue, but the resize operations could be
152 * starved by updates, thus leading to long hash table bucket chains.
44bbe7fa
LJ
153 * Threads calling this API are NOT required to be registered RCU read-side
154 * threads. It can be called very early.(before rcu is initialized ...etc.)
7a9dcf9b
MD
155 */
156static inline
0422d92c 157struct cds_lfht *cds_lfht_new(unsigned long init_size,
0722081a 158 unsigned long min_nr_alloc_buckets,
747d725c 159 unsigned long max_nr_buckets,
b7d619b0
MD
160 int flags,
161 pthread_attr_t *attr)
7a9dcf9b 162{
7b17c13e 163 return _cds_lfht_new(init_size, min_nr_alloc_buckets, max_nr_buckets,
c1888f3a 164 flags, NULL, &rcu_flavor, attr);
7a9dcf9b
MD
165}
166
f0c29ed7 167/*
14044b37 168 * cds_lfht_destroy - destroy a hash table.
b7d619b0
MD
169 * @ht: the hash table to destroy.
170 * @attr: (output) resize worker thread attributes, as received by cds_lfht_new.
171 * The caller will typically want to free this pointer if dynamically
7f52427b
MD
172 * allocated. The attr point can be NULL if the caller does not
173 * need to be informed of the value passed to cds_lfht_new().
6878c72b
MD
174 *
175 * Return 0 on success, negative error value on error.
3df0c49c 176 * Threads calling this API need to be registered RCU read-side threads.
f0c29ed7 177 */
b7d619b0 178int cds_lfht_destroy(struct cds_lfht *ht, pthread_attr_t **attr);
f0c29ed7
MD
179
180/*
14044b37 181 * cds_lfht_count_nodes - count the number of nodes in the hash table.
7f52427b
MD
182 * @ht: the hash table.
183 * @split_count_before: Sample the node count split-counter before traversal.
184 * @count: Traverse the hash table, count the number of nodes observed.
7f52427b 185 * @split_count_after: Sample the node count split-counter after traversal.
0422d92c 186 *
f0c29ed7 187 * Call with rcu_read_lock held.
3df0c49c 188 * Threads calling this API need to be registered RCU read-side threads.
f0c29ed7 189 */
14044b37 190void cds_lfht_count_nodes(struct cds_lfht *ht,
7f52427b 191 long *split_count_before,
adc0de68 192 unsigned long *count,
7f52427b 193 long *split_count_after);
ab7d5fc6 194
f0c29ed7 195/*
14044b37 196 * cds_lfht_lookup - lookup a node by key.
0422d92c 197 * @ht: the hash table.
0422d92c 198 * @hash: the key hash.
6f554439
LJ
199 * @match: the key match function.
200 * @key: the current node key.
0422d92c 201 * @iter: Node, if found (output). *iter->node set to NULL if not found.
f0c29ed7 202 *
f0c29ed7 203 * Call with rcu_read_lock held.
3df0c49c 204 * Threads calling this API need to be registered RCU read-side threads.
f0c29ed7 205 */
6f554439 206void cds_lfht_lookup(struct cds_lfht *ht, unsigned long hash,
996ff57c 207 cds_lfht_match_fct match, const void *key,
6f554439 208 struct cds_lfht_iter *iter);
ab7d5fc6 209
f0c29ed7 210/*
3883c0e5 211 * cds_lfht_next_duplicate - get the next item with same key (after a lookup).
0422d92c
MD
212 * @ht: the hash table.
213 * @match: the key match function.
04db56f8 214 * @key: the current node key.
0422d92c 215 * @iter: Node, if found (output). *iter->node set to NULL if not found.
f0c29ed7 216 *
9be0828e
MD
217 * Uses an iterator initialized by a lookup. Important: the iterator
218 * _needs_ to be initialized before calling cds_lfht_next_duplicate.
adc0de68
MD
219 * Sets *iter-node to the following node with same key.
220 * Sets *iter->node to NULL if no following node exists with same key.
221 * RCU read-side lock must be held across cds_lfht_lookup and
222 * cds_lfht_next calls, and also between cds_lfht_next calls using the
223 * node returned by a previous cds_lfht_next.
224 * Call with rcu_read_lock held.
3df0c49c 225 * Threads calling this API need to be registered RCU read-side threads.
f0c29ed7 226 */
0422d92c 227void cds_lfht_next_duplicate(struct cds_lfht *ht,
996ff57c 228 cds_lfht_match_fct match, const void *key,
04db56f8 229 struct cds_lfht_iter *iter);
4e9b9fbf
MD
230
231/*
232 * cds_lfht_first - get the first node in the table.
0422d92c
MD
233 * @ht: the hash table.
234 * @iter: First node, if exists (output). *iter->node set to NULL if not found.
4e9b9fbf
MD
235 *
236 * Output in "*iter". *iter->node set to NULL if table is empty.
237 * Call with rcu_read_lock held.
3df0c49c 238 * Threads calling this API need to be registered RCU read-side threads.
4e9b9fbf
MD
239 */
240void cds_lfht_first(struct cds_lfht *ht, struct cds_lfht_iter *iter);
241
242/*
243 * cds_lfht_next - get the next node in the table.
0422d92c
MD
244 * @ht: the hash table.
245 * @iter: Next node, if exists (output). *iter->node set to NULL if not found.
4e9b9fbf
MD
246 *
247 * Input/Output in "*iter". *iter->node set to NULL if *iter was
248 * pointing to the last table node.
249 * Call with rcu_read_lock held.
3df0c49c 250 * Threads calling this API need to be registered RCU read-side threads.
4e9b9fbf
MD
251 */
252void cds_lfht_next(struct cds_lfht *ht, struct cds_lfht_iter *iter);
ab7d5fc6 253
18117871 254/*
14044b37 255 * cds_lfht_add - add a node to the hash table.
0422d92c
MD
256 * @ht: the hash table.
257 * @hash: the key hash.
258 * @node: the node to add.
f0c29ed7 259 *
48ed1c18 260 * This function supports adding redundant keys into the table.
3df0c49c
MD
261 * Call with rcu_read_lock held.
262 * Threads calling this API need to be registered RCU read-side threads.
f0c29ed7 263 */
0422d92c
MD
264void cds_lfht_add(struct cds_lfht *ht, unsigned long hash,
265 struct cds_lfht_node *node);
f0c29ed7
MD
266
267/*
14044b37 268 * cds_lfht_add_unique - add a node to hash table, if key is not present.
0422d92c 269 * @ht: the hash table.
6f554439 270 * @hash: the node's hash.
0422d92c 271 * @match: the key match function.
04db56f8 272 * @key: the node's key.
0422d92c 273 * @node: the node to try adding.
f0c29ed7 274 *
6878c72b 275 * Return the node added upon success.
860d07e8
MD
276 * Return the unique node already present upon failure. If
277 * cds_lfht_add_unique fails, the node passed as parameter should be
278 * freed by the caller.
f0c29ed7 279 * Call with rcu_read_lock held.
3df0c49c 280 * Threads calling this API need to be registered RCU read-side threads.
48ed1c18
MD
281 *
282 * The semantic of this function is that if only this function is used
283 * to add keys into the table, no duplicated keys should ever be
284 * observable in the table. The same guarantee apply for combination of
9357c415 285 * add_unique and add_replace (see below).
18117871 286 */
adc0de68 287struct cds_lfht_node *cds_lfht_add_unique(struct cds_lfht *ht,
6f554439 288 unsigned long hash,
0422d92c 289 cds_lfht_match_fct match,
996ff57c 290 const void *key,
adc0de68 291 struct cds_lfht_node *node);
3eca1b8c 292
48ed1c18 293/*
9357c415 294 * cds_lfht_add_replace - replace or add a node within hash table.
0422d92c 295 * @ht: the hash table.
6f554439 296 * @hash: the node's hash.
0422d92c 297 * @match: the key match function.
04db56f8 298 * @key: the node's key.
0422d92c 299 * @node: the node to add.
48ed1c18
MD
300 *
301 * Return the node replaced upon success. If no node matching the key
302 * was present, return NULL, which also means the operation succeeded.
303 * This replacement operation should never fail.
304 * Call with rcu_read_lock held.
3df0c49c 305 * Threads calling this API need to be registered RCU read-side threads.
48ed1c18
MD
306 * After successful replacement, a grace period must be waited for before
307 * freeing the memory reserved for the returned node.
308 *
309 * The semantic of replacement vs lookups is the following: if lookups
9357c415
MD
310 * are performed between a key unique insertion and its removal, we
311 * guarantee that the lookups and get next will always find exactly one
312 * instance of the key if it is replaced concurrently with the lookups.
48ed1c18
MD
313 *
314 * Providing this semantic allows us to ensure that replacement-only
315 * schemes will never generate duplicated keys. It also allows us to
9357c415 316 * guarantee that a combination of add_replace and add_unique updates
48ed1c18
MD
317 * will never generate duplicated keys.
318 */
9357c415 319struct cds_lfht_node *cds_lfht_add_replace(struct cds_lfht *ht,
6f554439 320 unsigned long hash,
0422d92c 321 cds_lfht_match_fct match,
996ff57c 322 const void *key,
adc0de68 323 struct cds_lfht_node *node);
48ed1c18 324
f0c29ed7 325/*
929ad508 326 * cds_lfht_replace - replace a node pointed to by iter within hash table.
0422d92c
MD
327 * @ht: the hash table.
328 * @old_iter: the iterator position of the node to replace.
2e79c445
MD
329 * @hash: the node's hash.
330 * @match: the key match function.
331 * @key: the node's key.
332 * @new_node: the new node to use as replacement.
f0c29ed7 333 *
9357c415 334 * Return 0 if replacement is successful, negative value otherwise.
2e79c445
MD
335 * Replacing a NULL old node or an already removed node will fail with
336 * -ENOENT.
337 * If the hash or value of the node to replace and the new node differ,
338 * this function returns -EINVAL without proceeding to the replacement.
9357c415
MD
339 * Old node can be looked up with cds_lfht_lookup and cds_lfht_next.
340 * RCU read-side lock must be held between lookup and replacement.
341 * Call with rcu_read_lock held.
3df0c49c 342 * Threads calling this API need to be registered RCU read-side threads.
9357c415
MD
343 * After successful replacement, a grace period must be waited for before
344 * freeing the memory reserved for the old node (which can be accessed
345 * with cds_lfht_iter_get_node).
346 *
347 * The semantic of replacement vs lookups is the following: if lookups
348 * are performed between a key unique insertion and its removal, we
349 * guarantee that the lookups and get next will always find exactly one
350 * instance of the key if it is replaced concurrently with the lookups.
351 *
352 * Providing this semantic allows us to ensure that replacement-only
353 * schemes will never generate duplicated keys. It also allows us to
354 * guarantee that a combination of add_replace and add_unique updates
355 * will never generate duplicated keys.
356 */
2e79c445
MD
357int cds_lfht_replace(struct cds_lfht *ht,
358 struct cds_lfht_iter *old_iter,
359 unsigned long hash,
360 cds_lfht_match_fct match,
361 const void *key,
9357c415
MD
362 struct cds_lfht_node *new_node);
363
364/*
365 * cds_lfht_del - remove node pointed to by iterator from hash table.
0422d92c 366 * @ht: the hash table.
bc8c3c74 367 * @node: the node to delete.
9357c415
MD
368 *
369 * Return 0 if the node is successfully removed, negative value
370 * otherwise.
bc8c3c74 371 * Deleting a NULL node or an already removed node will fail with a
9357c415 372 * negative value.
bc8c3c74
MD
373 * Node can be looked up with cds_lfht_lookup and cds_lfht_next,
374 * followed by use of cds_lfht_iter_get_node.
9357c415 375 * RCU read-side lock must be held between lookup and removal.
f0c29ed7 376 * Call with rcu_read_lock held.
3df0c49c 377 * Threads calling this API need to be registered RCU read-side threads.
48ed1c18 378 * After successful removal, a grace period must be waited for before
9357c415
MD
379 * freeing the memory reserved for old node (which can be accessed with
380 * cds_lfht_iter_get_node).
f0c29ed7 381 */
bc8c3c74 382int cds_lfht_del(struct cds_lfht *ht, struct cds_lfht_node *node);
ab7d5fc6 383
df55172a
MD
384/*
385 * cds_lfht_is_node_deleted - query if a node is removed from hash table.
386 *
387 * Return non-zero if the node is deleted from the hash table, 0
388 * otherwise.
389 * Node can be looked up with cds_lfht_lookup and cds_lfht_next,
390 * followed by use of cds_lfht_iter_get_node.
391 * RCU read-side lock must be held between lookup and call to this
392 * function.
393 * Call with rcu_read_lock held.
394 * Threads calling this API need to be registered RCU read-side threads.
395 */
396int cds_lfht_is_node_deleted(struct cds_lfht_node *node);
397
f0c29ed7 398/*
14044b37 399 * cds_lfht_resize - Force a hash table resize
0422d92c 400 * @ht: the hash table.
1475579c 401 * @new_size: update to this hash table size.
3df0c49c
MD
402 *
403 * Threads calling this API need to be registered RCU read-side threads.
f0c29ed7 404 */
1475579c 405void cds_lfht_resize(struct cds_lfht *ht, unsigned long new_size);
464a1ec9 406
6d320126
MD
407/*
408 * Note: cds_lfht_for_each are safe for element removal during
409 * iteration.
410 */
411#define cds_lfht_for_each(ht, iter, node) \
412 for (cds_lfht_first(ht, iter), \
413 node = cds_lfht_iter_get_node(iter); \
414 node != NULL; \
415 cds_lfht_next(ht, iter), \
416 node = cds_lfht_iter_get_node(iter))
417
6f554439
LJ
418#define cds_lfht_for_each_duplicate(ht, hash, match, key, iter, node) \
419 for (cds_lfht_lookup(ht, hash, match, key, iter), \
6d320126
MD
420 node = cds_lfht_iter_get_node(iter); \
421 node != NULL; \
422 cds_lfht_next_duplicate(ht, match, key, iter), \
423 node = cds_lfht_iter_get_node(iter))
424
425#define cds_lfht_for_each_entry(ht, iter, pos, member) \
426 for (cds_lfht_first(ht, iter), \
427 pos = caa_container_of(cds_lfht_iter_get_node(iter), \
428 typeof(*(pos)), member); \
0b0627bf 429 &(pos)->member != NULL; \
6d320126
MD
430 cds_lfht_next(ht, iter), \
431 pos = caa_container_of(cds_lfht_iter_get_node(iter), \
432 typeof(*(pos)), member))
433
6f554439 434#define cds_lfht_for_each_entry_duplicate(ht, hash, match, key, \
6d320126 435 iter, pos, member) \
6f554439 436 for (cds_lfht_lookup(ht, hash, match, key, iter), \
6d320126
MD
437 pos = caa_container_of(cds_lfht_iter_get_node(iter), \
438 typeof(*(pos)), member); \
0b0627bf 439 &(pos)->member != NULL; \
6d320126
MD
440 cds_lfht_next_duplicate(ht, match, key, iter), \
441 pos = caa_container_of(cds_lfht_iter_get_node(iter), \
442 typeof(*(pos)), member))
443
01389791
MD
444#ifdef __cplusplus
445}
446#endif
447
a42cc659 448#endif /* _URCU_RCULFHASH_H */
This page took 0.073517 seconds and 4 git commands to generate.
|
__label__pos
| 0.792615 |
Question
In a carefully controlled experiment, bacteria are allowed to grow for a week. The number of bacteria are recorded at the end of each day with these results: 20, 40, 80, 160, 320, 640, 1280.
Construct a scatterplot and identify the mathematical model that best fits the given data. Assume that the model is to be used only for the scope of the given data, and consider only linear, quadratic, logarithmic, exponential, and power models.
$1.99
Sales0
Views32
Comments0
• CreatedMay 03, 2015
• Files Included
Post your question
5000
|
__label__pos
| 0.695638 |
当前位置：网站首页 > 教程 > 帝国cms教程 > 帝国CMS7.0数据库记录所有浏览访问的会员教程
帝国CMS7.0数据库记录所有浏览访问的会员教程
蓝色枫叶 蓝色枫叶 2020-05-25 前往当前专题: 帝国cms教程
1、新闻系统数据表中字段管理中添加“visituserid”字段，字段类型为“CHAR ”。
2、在需要统计的页面的<head></head>中添加如下代码
<script src="[!--news.url--]/ly/jquery.js" type="text/javascript"></script>
<script>
//信息ID
var id = [!--id--];
//登陆用户
var userid = <?=$lguserid=intval(getcvar('mluserid'))?>;
$(function(){
if(userid)
{
$.post(
'/ly/recorduser/index.php',
{userid:userid,id:id},
"html"
);
}
})
</script>
3、添加数据代码
可以下载压缩包将文件放在根目录
文件路径 根目录/ly/recorduser/index.php
index.php文件代码：
<?php
require('../../e/class/connect.php'); //引入数据库配置文件和公共函数文件
require('../../e/class/db_sql.php'); //引入数据库操作文件
include('../../e/class/functions.php');
$link=db_connect(); //连接MYSQL
$empire=new mysqlquery(); //声明数据库操作类
if(!$_POST['userid'])
{
exit;
}
/*
userid
visituserid
/
表名称：
栏目ID
信息ID
表名称@@@栏目ID@@@信息ID：：：：：：
/
*/
//查询是否已有userid
if($user=$empire->fetch1("select * from {$dbtbpre}ecms_news where id = {$_POST['id']}"))
{
//格式化字符串
$visituserid="{$_POST['userid']}";
//信息分隔符
$dot='';
//判断是否已有记录数
if(strstr($user['visituserid'],$visituserid))
{
//已有记录返回空
die;
}
if($user['visituserid']!='')
{
$dot=',';
}
//大于1000调记录数去掉最后的一条信息
if($user['visituserid'] && substr_count($user['visituserid'],$dot)>=999)
{
//去除最后一条记录数
$arr=explode(',',$user['visituserid']);
$arrvisituserid='';
$dot1=$dot;
for($i=0;$i<count($arr);$i++)
{
if($i!=(count($arr)-1))
{
if($i==(count($arr)-2))
{
$dot1='';
}
$arrvisituserid.=$arr[$i].$dot1;
}
}
$visituserid.=$dot.$arrvisituserid;
}
else
{
$visituserid.=$dot.$user['visituserid'];
}
//不存在的记录数、更新表
$empire->query("update {$dbtbpre}ecms_news set `visituserid` = '{$visituserid}' where id = {$_POST['id']}");
}
//没有记录数插入一条
else
{
$visituserid="{$_POST['userid']}";
$sql=$empire->query(" INSERT INTO `{$dbtbpre}ecms_news` `visituserid` VALUES '{$visituserid}' ");
}
?>
4、调用已阅人员列表
在需要调用的地方添加代码如下：
<div class="ct_fw"><li><b>已阅人：</b></li>
<!--判断visituserid是否为空-->
<?php
if($navinfor[visituserid])
{
?>
<!--visituserid不为空时显示开始-->
<?php
$record=$empire->fetch1("select * from {$dbtbpre}ecms_news where id = $navinfor[id]");
if($record)
{
$info=explode(",",$record['visituserid']);
$visituserid='';
foreach($info as $v)
{
$arr=explode($v);
$sql=$empire->fetch1("select * from {$dbtbpre}enewsmember where userid = $v ");
$visituserid.="<li><a href='/e/space/?userid=$v' title='点击访问{$sql[username]}的空间' target='_blank'>{$sql[username]}</a></li>";
//print_r($arr);
//die;
}
}
?>
<?=$visituserid?>
<!--visituserid不为空时显示结束-->
<?php
}
else
{
?>
<!--visituserid为空时显示开始-->
<!--visituserid为空时显示结束-->
<?php
}
?>
</div>
这样就可以了。
附件请点击下载：
立即下载
蓝色枫叶
蓝色枫叶
TA很懒，啥都没写...
Copyright 蓝色枫叶 www.lansefengye Rights Reserved.
|
__label__pos
| 0.991914 |
Processing Application on a touch screen tablet
Hi,
I have developed an application on processing that I am trying to run on a windows tablet. I am facing problems with its touch screen. It does not detect touch properly and misses it generally. When you tap on the button speedily multiple times the tap gets detected. For example, the application runs perfectly fine if I perform all actions using a double tap instead of a single tab. Why is that? Can anyone please help?
I have used mousePressed for detecting touch.
Also when i run it on my computer using a mouse it works fine with a single click.
Tagged:
Answers
• I have the exact same problem, and i tried two different computers, both running win8 and the problem is consistent.
If you sweep the button it detects without any problems, but a single press will not work. But by far the worst problem i have encountered are that if you press one button and then after a while presses another one, sometimes the first one gets pressed, even though you are pressing a button at the other end of the screen. It seems like the cursor is still hovering over that button and that the program somehow detects the press before the position.
This made me wonder if processing has some way to force the cursor to a given position. One could make the code in such way, that we don't detect buttonpresses but we detect if the mouse are hovering over the button equivalent to a buttonpress. The cursor will flicker between the point on the screen you press and the default position, but once you release it will always be on the default position. And you can just hide the cursor, so the user won't see it flickering. But this requires that there is such a command in processing???
• I confirm that mouse-activity sucks in Processing with win8.
The problem come from how Processing handle it - I don't know how it works, but there is an issue somewhere - .
You have to handle it by yourself, without using the property "mousePressed" , never. The method "mousePressed" looks to work as expected but the property is not stable enough. You should create a local variable/method "mouseIsPressed" in your classes and modify it from the main "mousePressed" method
• tlecoz could you try to elaborate a bit on that? My biggest problem by far is that the cursor hovers over the last pressed button and if another button is pressed, it will first press the previous button before pressing the selected button. So frustrating. How would one write a function that solves this problem?
• Oh, I think in your case, the problem come from your code . Can you post it, then we will be able to see what's wrong in it
• First of thanks for your help. Sometimes i am so consumed by getting things to work that i forget to express my gratitude over how helpful people are :)
My code are to long and uses serial to communicate with an arduino, but the problem can be recreated by using the example code from the ControlP5 library:
I do not believe that the error has anything to do with the ControlP5 library. In my sketch i have som buttons that i have drawen from scratch and does not use the controlP5 library. If i press on one with the mouse, there are no problem, but when pressing on the screen i have to swipe the screen instead of pushing to get an accepted press.
Anyway try this code and see if you get the same result as i have described at the end of the code (can be found in the ControlP5 example library "ControlP5 Button"):
/**
* ControlP5 Button
* this example shows how to create buttons with controlP5.
*
* find a list of public methods available for the Button Controller
* at the bottom of this sketch's source code
*
* by Andreas Schlegel, 2012
* www.sojamo.de/libraries/controlp5
*
*/
import controlP5.*;
ControlP5 cp5;
int myColor = color(255);
int c1,c2;
float n,n1;
void setup() {
size(400,600);
noStroke();
cp5 = new ControlP5(this);
// create a new button with name 'buttonA'
cp5.addButton("colorA")
.setValue(0)
.setPosition(100,100)
.setSize(200,19)
;
// and add another 2 buttons
cp5.addButton("colorB")
.setValue(100)
.setPosition(100,120)
.setSize(200,19)
;
cp5.addButton("colorC")
.setPosition(100,140)
.setSize(200,19)
.setValue(0)
;
PImage[] imgs = {loadImage("button_a.png"),loadImage("button_b.png"),loadImage("button_c.png")};
cp5.addButton("play")
.setValue(128)
.setPosition(140,300)
.setImages(imgs)
.updateSize()
;
cp5.addButton("playAgain")
.setValue(128)
.setPosition(210,300)
.setImages(imgs)
.updateSize()
;
}
void draw() {
background(myColor);
myColor = lerpColor(c1,c2,n);
n += (1-n)* 0.1;
}
public void controlEvent(ControlEvent theEvent) {
println(theEvent.getController().getName());
n = 0;
}
// function colorA will receive changes from
// controller with name colorA
public void colorA(int theValue) {
println("a button event from colorA: "+theValue);
c1 = c2;
c2 = color(0,160,100);
}
// function colorB will receive changes from
// controller with name colorB
public void colorB(int theValue) {
println("a button event from colorB: "+theValue);
c1 = c2;
c2 = color(150,0,0);
}
// function colorC will receive changes from
// controller with name colorC
public void colorC(int theValue) {
println("a button event from colorC: "+theValue);
c1 = c2;
c2 = color(255,255,0);
}
public void play(int theValue) {
println("a button event from buttonB: "+theValue);
c1 = c2;
c2 = color(0,0,0);
}
Okay so try to press the ColorA button with the mouse and then the ColorB button. You will se that in the processing text prompt it changes just as expected, First it writes ColorA and then ColorB. Then do the same using the touch screen. You will see that it writes ColorA and then ColorA again, even though you pressed ColorB. A third touch on ColorB will get you the ColorB.
• Hi, I am facing the exact same problem today with the touchscreen of a Raspberry Pi 3. The problem is that a first tap on the screen sets the (X,Y) position of the mouse pointer (even though it's supposed to be a touch screen and therefore the concept of a mouse pointer is subjected to discussion), while a second tap sets new (X,Y) values, but adds a click event at the former position. This explains why ColorA appears twice before ColorB displays.
The problem is awful when dealing with Knobs or Toggle buttons: by clicking away from the controller if the "mouse" (equivalently mouseX and mouseY variables) is positioned on the controller, the controller is triggered before the "mouse" is moved (equivalently before mouseX and mouseY are set to new values corresponding to the click away from the controller).
How could I fix such behavior?
Thanks!
• When I used P5Control this problem occurred to me. Then, I changed to 4GP library and it accept one touch as button pressed.
• Has anyone made any progress on a workaround for this issue with the ControlP5 library? I'm having the same issues with touch input on Windows that palmhoej and jellium described.
Sign In or Register to comment.
|
__label__pos
| 0.786369 |
First Level Screening:
To apply you need to attempt one skill assessment test as recruiter has attached skill assessment test with this job and wants to see your obtained marks,
So be carefull while attempting this skill assessment test
All the best!
Sorry, You don't have enough Tech Quotient to apply for this job.
Please participate in the Skill test for skills given below in order to earn Tech Quotient and then apply again.
Anybody can ask a question
Follow people, get updated on answers, learn and much more ...
• 10000+ Questions
• 90000+ Answers
• 50000+ Users
• 1000+ Experts
What is Q&A?
Ask questions, post answers, like and comment on answers and much more …
• Ask Questions
• Post Answers
• Post Comments
• Like Q&A
Are you looking for the answers to your Tech questions?
Sorry, You don't have enough reputation score to post a question
Please increase your reputation score* by doing some activities on the site as below and then only you can post questions on Techgig.com
Activities:
* Updated reputation score will be reflected on next day
• Trouble writing controller actions that work with JQuery to update database
I have an html table that holds categories of things. Each row consists of a category id and name that are looped in from the model. There are also two buttons in each row. One that I want to use to set the state of the row to enabled and the other to set it to disabled:
<table id="categoryList" class="table">
<thead>
<tr>
<th>Category ID</th>
<th>Category Name</th>
</tr>
</thead>
<tbody>
@foreach (var item in Model.Categories)
{
<tr>
<td>@item.id</td>
<td>@item.name</td>
<td>
<button class="btn btn-success categoryEnabled">Enabled</button>
<button class="btn btn-danger categoryDisabled" style="display: none;">Disabled</button>
</td>
</tr>
}
</tbody>
</table>
When I say set to enabled or disabled I mean change the bit value for that row in an SQL table column called state. So, I basically just need the buttons to toggle that bit value for the row in which it is clicked.
Here is where I'm at with the solution:
Here's the Jquery I am using to try to change the bit value for the selected row when each button is clicked:
$(".categoryEnabled").on("click", function () {
$(this).hide();
$(this).next().show();
DisableRow($(this).attr('id'));
});
$(".categoryDisabled").on("click", function () {
$(this).hide();
$(this).prev().show();
EnableRow($(this).attr('id'));
});
function EnableRow(id) {
$.post("@Url.Action("DisableRow", "Category")", { "Id": id }, function (response) {
if (response.success) {
alert('Row Disabled!');
} else {
alert('Error disabling row!');
}
});
}
function DisableRow(id) {
$.post("@Url.Action("EnableRow", "Category")", { "Id": id }, function (response) {
if (response.success) {
alert('Row Enabled!');
} else {
alert('Error enabling row!');
}
});
You can see that I'm trying to connect these to a controller action in the CategoryController. I am just not too sure what to put into these actions to make the connection to the state column of the Category table using entity framework.
public ActionResult DisableRow()
{
}
public ActionResult EnableRow()
{
}
I would also need a loop to identity the row that I'm trying to update:
int i = 0;
foreach (var row in Model.Rows)
{
string id = "Row" + i.ToString() + "Enable";
i +=1;
}
It would also be helpful for you to see the category object as I have it:
namespace Rework.Models
{
using System;
using System.Collections.Generic;
public enum StatesTypes
{
Disabled = 0,
Enabled = 1
}
public partial class Category
{
public int id { get; set; }
public string name { get; set; }
public StatesTypes state { get; set; }
}
}
Just not sure if there is a better way or where this would fit in. Thanks for your help!
c#, jquery, sql-server, asp.net-mvc
Add Your Answer
user
add answer
A
I checked your code and it was properly coded just you want to understand ajax and MVC. Here you use $post method so your action should mark with HttpPost attribute and you have to write update query using LInq to SQL (entity framework) in your action method. Form javascript/jqeury You have to define unique id for your enable and disabled button or you can use only one button and change its text value to update state. When your $post return success then find button with id and change its text value.
Similar Asked Questions
View All Questions...
Give Techgig a try today!
Learn. Compete. Showcase your skills. Get hired.
|
__label__pos
| 0.950614 |
0
\$\begingroup\$
I'm new in Unity and creating a game. So I have a class PicManager in which I have to load my images(sprites) from assets into a List and then use them in my game. What is the proper way to load multiple images from a folder in Assets?
I know, that I can use Sprite[] sprites = Resources.LoadAll<Sprite>(texture.name); But this article of Unity says not to use Resource folder.
\$\endgroup\$
• 1
\$\begingroup\$ May I ask why you want to load all images at the same time? You can simply do "public Sprite mySprite;" for each image you want to use, and drag and drop from the inspector? If you want multiple images in an array (to iterate through them for example) you can use public Sprite[] mySprites; and drag and drop from the inspector. \$\endgroup\$ – TomTsagk Oct 8 '18 at 14:28
• \$\begingroup\$ Yeap, I can do by your way, but: I have a class PicManager, which is not inherited from 'MonoBehaviour', it's just a general C# class (may be its very wrong, I suppose, but for me it's conveniently). For me it seems more flexible to load sprites dynamically. Idk yet if this approach is correct or not \$\endgroup\$ – Alexander Oct 8 '18 at 15:07
• \$\begingroup\$ It's a nice approach if you are using a custom engine, or you are using no engine at all, when Unity can take care of loading the assets for you, why would you not take advantage of that? It's one of the reasons one would use a game engine: focus on the game itself. \$\endgroup\$ – TomTsagk Oct 8 '18 at 15:28
2
\$\begingroup\$
The reason why the article tells you to not use the Resources folder is exactly because it leads to the anti-pattern you want to create here: Loading multiple images from a folder in Assets before the engine decided that it acutally needs them. So if you insist on doing this, then all that advise is invalid and you can use the method described in the question.
An alternative method which might replicate your architecture in a more Unity-friendly way would be:
• Turn your PicManager into a MonoBehaviour
• Make Sprite[] sprites a public variable if it isn't already
• Add a new game object with that behaviour
• Add the sprites you need to the game object through the inspector.
But there is just one scenario I could think of where this would make sense: If you have game objects which frequently change their appearance during the game. In that case you could store all the available appearances in the pic manager. When the appearance of a type of game object does not change, then it would be better to assign the sprite directly to the game object and create a prefab for each type of game object which you then instantiate whenever you need one.
\$\endgroup\$
• \$\begingroup\$ +1, if you directly use the Sprite class to give a sprite to an object, Unity will decide when is the best way to load the asset for you, so it won't start loading assets that it's not going to use any time soon. \$\endgroup\$ – TomTsagk Oct 8 '18 at 15:49
1
\$\begingroup\$
If you must load from assets without using Resources.Load, I'd suggest checking out unity's scriptable objects [ScriptableObjects] you save them as assets and can create a list of those objects.
But I also agree with Tom, use the engine. You can always have another script that inherits from monobehavior and implements PicManager if abstraction is what you're going for.
\$\endgroup\$
Your Answer
By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy
Not the answer you're looking for? Browse other questions tagged or ask your own question.
|
__label__pos
| 0.636907 |
<< Chapter < Page Chapter >> Page >
Mathematics
Grade 5
Measurement and time
Module 51
Length
In this learning unit we shall be looking at different units used to measure length, as well as at the importance of measuring accurately.
Activity 1:
• To measure and record [LO 4.5.3]
• To measure accurately with the appropriate measuring instruments [LO 4.7.3]
1. Let us start right away! How well do you know yourself? Measure the following as accurately as possible (your friend may help you):
1.1 the length of your thumb nail
1.2 the length of your little finger
1.3 the length of your right foot
1.4 the length of your left arm from your shoulder to the tip of your middle finger
1.5 How tall are you?
1.6 How high can you reach when you jump up from the ground?
1.7 How much higher is this than your height?
2. What did you use to measure the above?
3. What other measuring apparatus could we also use to measure length?
Do you still remember?
1 cm = 10 mm
1 m = 100 cm
1 m = 1 000 mm
1 km = 1 000 m
Did you know?
• One metre is roughly the distance from an adult’s nose to the tip of his middle finger on his stretched out hand.
• The length of a fingernail is roughly 1 cm.
• The length of a hand is roughly 10 cm.
• The space underneath your fingernail is roughly 1 mm.
• The breadth of a little finger is roughly 10 mm.
4. Work together with a friend and complete the following table.
Measure Estimate Actual Measurement Difference
a) the height of your educator ...................... ....................... .......................
b) the breadth of your classroom ...................... ....................... .......................
c) the height of your desk/table ...................... ....................... .......................
d) the total length of the blackboard in the classroom ...................... ....................... .......................
Activity 2:
To solve problems that include selecting, calculating with and converting standard units [lo 4.6]
1. It is important for us to know which measuring units are used for specific lengths. In order to do that correctly, we must know exactly how long the different measuring units are. Let us see how good you are at this! Choose a suitable unit to measure the following:
1.1 The chest size of Dad’s suit (of clothes) is 102 ____
1.2 The height of my bedroom wall is 4 ____
1.3 The breadth of the stoep of the farmhouse is 2,5 ______
1.4 The thickness of my dictionary is 40 _____
1.5 The distance between Johannesburg and Cape Town is more than 1 000 _____
1.6 The depth of the water in our swimming pool is 1,500 _____
2. Circle the measurement that is the closest to reality:
2.1 Our classroom door is about ____high.
(a) 20 m
(b) 200 mm
(c) 2 km
(d) 2 m
2.2 My foot is about ____long.
(a) 26 cm
(b) 26 mm
(c) 26 km
(d) 26 m
2.3 The distance from Durban to East London is ____
(a) 674 mm
(b) 674 km
(c) 674 m
(d) 674 cm
3. Let us look at the way of writing length in the decimal form:
We already know that 10 mm = 1 cm
Thus: 25 mm = 10 + 10 + 5 mm= 1cm + 1 cm + 5 mm= 2 cm + 5 mm= 2,5 cm of 2 1 2 size 12{ { { size 8{1} } over { size 8{2} } } } {} cm
Complete the table:
Number of mm 10 85 ............ 245 ............ 1 026 ............
Number of cm 1 ............ 4,2 ............ 17,9 ............ 146,3
Questions & Answers
show that the set of all natural number form semi group under the composition of addition
Nikhil Reply
what is the meaning
Dominic
explain and give four Example hyperbolic function
Lukman Reply
_3_2_1
felecia
⅗ ⅔½
felecia
_½+⅔-¾
felecia
The denominator of a certain fraction is 9 more than the numerator. If 6 is added to both terms of the fraction, the value of the fraction becomes 2/3. Find the original fraction. 2. The sum of the least and greatest of 3 consecutive integers is 60. What are the valu
SABAL Reply
1. x + 6 2 -------------- = _ x + 9 + 6 3 x + 6 3 ----------- x -- (cross multiply) x + 15 2 3(x + 6) = 2(x + 15) 3x + 18 = 2x + 30 (-2x from both) x + 18 = 30 (-18 from both) x = 12 Test: 12 + 6 18 2 -------------- = --- = --- 12 + 9 + 6 27 3
Pawel
2. (x) + (x + 2) = 60 2x + 2 = 60 2x = 58 x = 29 29, 30, & 31
Pawel
ok
Ifeanyi
on number 2 question How did you got 2x +2
Ifeanyi
combine like terms. x + x + 2 is same as 2x + 2
Pawel
x*x=2
felecia
2+2x=
felecia
×/×+9+6/1
Debbie
Q2 x+(x+2)+(x+4)=60 3x+6=60 3x+6-6=60-6 3x=54 3x/3=54/3 x=18 :. The numbers are 18,20 and 22
Naagmenkoma
Mark and Don are planning to sell each of their marble collections at a garage sale. If Don has 1 more than 3 times the number of marbles Mark has, how many does each boy have to sell if the total number of marbles is 113?
mariel Reply
Mark = x,. Don = 3x + 1 x + 3x + 1 = 113 4x = 112, x = 28 Mark = 28, Don = 85, 28 + 85 = 113
Pawel
how do I set up the problem?
Harshika Reply
what is a solution set?
Harshika
find the subring of gaussian integers?
Rofiqul
hello, I am happy to help!
Shirley Reply
please can go further on polynomials quadratic
Abdullahi
hi mam
Mark
I need quadratic equation link to Alpa Beta
Abdullahi Reply
find the value of 2x=32
Felix Reply
divide by 2 on each side of the equal sign to solve for x
corri
X=16
Michael
Want to review on complex number 1.What are complex number 2.How to solve complex number problems.
Beyan
yes i wantt to review
Mark
16
Makan
x=16
Makan
use the y -intercept and slope to sketch the graph of the equation y=6x
Only Reply
how do we prove the quadratic formular
Seidu Reply
please help me prove quadratic formula
Darius
hello, if you have a question about Algebra 2. I may be able to help. I am an Algebra 2 Teacher
Shirley Reply
thank you help me with how to prove the quadratic equation
Seidu
may God blessed u for that. Please I want u to help me in sets.
Opoku
what is math number
Tric Reply
4
Trista
x-2y+3z=-3 2x-y+z=7 -x+3y-z=6
Sidiki Reply
can you teacch how to solve that🙏
Mark
Solve for the first variable in one of the equations, then substitute the result into the other equation. Point For: (6111,4111,−411)(6111,4111,-411) Equation Form: x=6111,y=4111,z=−411x=6111,y=4111,z=-411
Brenna
(61/11,41/11,−4/11)
Brenna
x=61/11 y=41/11 z=−4/11 x=61/11 y=41/11 z=-4/11
Brenna
Need help solving this problem (2/7)^-2
Simone Reply
x+2y-z=7
Sidiki
what is the coefficient of -4×
Mehri Reply
-1
Shedrak
A soccer field is a rectangle 130 meters wide and 110 meters long. The coach asks players to run from one corner to the other corner diagonally across. What is that distance, to the nearest tenths place.
Kimberly Reply
Jeannette has $5 and $10 bills in her wallet. The number of fives is three more than six times the number of tens. Let t represent the number of tens. Write an expression for the number of fives.
August Reply
What is the expressiin for seven less than four times the number of nickels
Leonardo Reply
How do i figure this problem out.
how do you translate this in Algebraic Expressions
linda Reply
why surface tension is zero at critical temperature
Shanjida
I think if critical temperature denote high temperature then a liquid stats boils that time the water stats to evaporate so some moles of h2o to up and due to high temp the bonding break they have low density so it can be a reason
s.
Need to simplify the expresin. 3/7 (x+y)-1/7 (x-1)=
Crystal Reply
. After 3 months on a diet, Lisa had lost 12% of her original weight. She lost 21 pounds. What was Lisa's original weight?
Chris Reply
Got questions? Join the online conversation and get instant answers!
Jobilize.com Reply
Get Jobilize Job Search Mobile App in your pocket Now!
Get it on Google Play Download on the App Store Now
Source: OpenStax, Mathematics grade 5. OpenStax CNX. Sep 23, 2009 Download for free at http://cnx.org/content/col10994/1.3
Google Play and the Google Play logo are trademarks of Google Inc.
Notification Switch
Would you like to follow the 'Mathematics grade 5' conversation and receive update notifications?
Ask
|
__label__pos
| 0.998043 |
Justin Wyllie Justin Wyllie - 5 months ago 8
HTML Question
Images in flex items causing equal width to break
enter image description here
The red borders are around flex items. They have
flex-grow: 1
These items are contained in a flex container:
width: 100%
display: flex
flex-direction: row
align-items: flex-end
As you can see the vertical alignment is working fine.
When I put the images in, the width of the images pushes the flex items to be bigger or smaller than they should be. The width of the images overrides the width of the flex items. What I want to say is something like:
Firstly make the flex items all the same size and then size the contained images (whatever their natural size) to be the size of their container (the flex item). I've tried
width: 100%
and
width: auto
on the images. Didn't help.
This image shows the equally spaced flex items (red borders). I want the images to fit into these boxes without causing the width of the box to change. This is the behaviour I get if I replace the flex items with table cells.
Screenshot
This Fiddle shows the 3 equal boxes: https://jsfiddle.net/justinwyllie/zdrd89gu/
.flex-container {
display: flex;
flex-direction: row;
align-items: flex-end;
}
.flex-boxes {
flex-grow: 1;
border: 2px solid red;
}
<div class="flex-container">
<div class="flex-boxes">A</div>
<div class="flex-boxes">B</div>
<div class="flex-boxes">C</div>
</div>
This one shows an image in the middle flex item. It has completely messed up the equal boxes. The question is what do I need to do to make the cat fit into the middle box? (Fit width-wise that is; i don't mind about height).
https://jsfiddle.net/justinwyllie/zdrd89gu/1/
.flex-container {
display: flex;
flex-direction: row;
align-items: flex-end;
}
.flex-boxes {
flex-grow: 1;
border: 2px solid red;
}
.cat {
width: auto;
}
<div class="flex-container">
<div class="flex-boxes">A</div>
<div class="flex-boxes">
<img class="cat" src="http://www.publicdomainpictures.net/pictures/30000/velka/annoyed-cat.jpg" />
</div>
<div class="flex-boxes">C</div>
</div>
Answer
The flex-grow property tells a flex item how to consume available space in the container.
In your second image, the empty items are all equal width because flex-grow: 1 tells them to distribute available space in the container equally among themselves.
Any content you put in these items can potentially override flex-grow since, as mentioned, flex-grow is based on the free space in the container and content consumes space.
If you want the items to maintain a fixed width, use flex-basis.
So instead of:
flex-grow: 1;
Try:
flex: 0 0 20%; /* don't grow, don't shrink, fixed width at 20% */
The 20% is just an example, if you wanted five items per row.
Here's your revised code:
jsFiddle
.flex-container {
display: flex;
flex-direction: row;
align-items: flex-end;
}
.flex-boxes {
/* flex-grow: 1; <-- REMOVE */
flex: 0 0 33.33%; /* NEW */
border: 2px solid red;
}
.cat {
width: auto;
}
<div class="flex-container">
<div class="flex-boxes">A</div>
<div class="flex-boxes">
<img class="cat" src="http://www.publicdomainpictures.net/pictures/30000/velka/annoyed-cat.jpg" />
</div>
<div class="flex-boxes">C</div>
</div>
Learn more here:
Comments
|
__label__pos
| 0.53196 |
t422-rgba-func-int-a
rgba() colors
WeasyPrint
Reference (good) by WeasyPrint
Reference (good) by this browser
This browser
Assertion
Test that rgba() values produce correct colors.
Source
1 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
2 <html>
3 <head>
4 <title>CSS Test: rgba() colors</title>
5 <link rel="author" title="L. David Baron" href="https://dbaron.org/">
6 <link rel="author" title="Mozilla Corporation" href="http://mozilla.com/">
7 <link rel="help" href="http://www.w3.org/TR/css3-color/#rgba-color">
8 <link rel="match" href="reference/t422-rgba-func-int-a-ref.htm">
9 <meta name="flags" content="">
10 <meta name="assert" content="Test that rgba() values produce correct colors.">
11 <style type="text/css">
12 #one { color: rgba(0, 0, 0, 1.0); background: rgba(255, 255, 255, 1.0); }
13 #two { color: rgba(255, 255, 255, 1.0); background: rgba(0, 0, 0, 1.0); }
14 #three { color: rgba(255, 0, 0, 1.0); }
15 #four { color: rgba(0, 255, 0, 1.0); }
16 #five { color: rgba(0, 0, 255, 1.0); }
17 </style>
18 </head>
19 <body>
20 <p id="one">This should be black text on a white background.</p>
21 <p id="two">This should be white text on a black background.</p>
22 <p id="three">This text should be red.</p>
23 <p id="four">This text should be green.</p>
24 <p id="five">This text should be blue.</p>
25 </body>
26 </html>
|
__label__pos
| 0.839887 |
Huge news!Announcing our $20M Series A led by Andreessen Horowitz.Learn more
Socket
Socket
Log inDemoInstall
← Back to Glossary
Glossary
Supply Chain Security
Introduction to Supply Chain Security#
The term "Supply Chain Security" is often associated with physical commodities and logistics, yet it's increasingly relevant in the digital realm, particularly in the software development industry. As our reliance on software grows, so does the need to secure the processes and products we depend upon.
In the context of software, the "supply chain" refers to the pipeline through which code is created, distributed, and implemented, and it involves various stages such as code creation, code repositories, development tools, and deployment environments. Supply Chain Security, therefore, involves implementing measures to ensure the integrity of each link in this chain.
In an era where open source software dominates and code sharing is the norm, securing the supply chain is a complex challenge. As developers, we integrate packages from various sources into our software, and each of these imported packages introduces potential risks.
Understanding the Open Source Ecosystem and its Risks#
Open source software has revolutionized the tech industry. Its primary principle is to encourage collaboration and sharing, making the process of building software more efficient and innovative. Today, a considerable portion of modern applications are built using open source components.
However, with the convenience and efficiency that open source offers, it also brings a myriad of security risks. When developers integrate third-party packages into their applications, they also incorporate the vulnerabilities that come with them. These vulnerabilities can be exploited by malicious actors to infiltrate systems, disrupt operations, or steal sensitive information.
Supply chain attacks are an increasingly popular form of cyber-attack, where the attackers inject malicious code into trusted components of the software supply chain. This can be done by hijacking an existing package, creating and spreading a malicious package, or infiltrating a repository to alter a package's code.
The Growing Threat of Supply Chain Attacks#
The rising popularity of open source has not gone unnoticed by malicious actors. Supply chain attacks have risen dramatically in the past few years, impacting trust in open source software and highlighting the need for more robust security measures.
Unlike typical cyber-attacks that directly target a system, supply chain attacks exploit the trust developers place in their tools and libraries. Attackers compromise one link in the software supply chain, intending to reach into the downstream users who implicitly trust that link. Notable instances, such as the event-stream and ua-parser-js incidents, showcase the large-scale impact these attacks can have.
The damage done by these attacks isn't limited to direct victims. They also erode trust in open source, a pillar of modern software development, which may indirectly hinder innovation and development speed.
Current Security Measures and Their Limitations#
In response to the threat landscape, the cybersecurity industry has developed various tools to protect the software supply chain. These primarily include vulnerability scanners and static analysis tools. However, these approaches tend to be reactive rather than proactive.
Vulnerability scanners, such as Snyk or Dependabot, look up packages to check if any known vulnerabilities have been reported to public CVE databases. However, these tools only find known vulnerabilities, and they cannot protect against newly introduced or undisclosed ones.
Static analysis tools, on the other hand, help identify bugs or potential issues in an application's codebase. They are effective for analyzing your code but are often too noisy and unactionable for examining thousands of lines of third-party code.
In other words, these tools may not be effective against supply chain attacks, which often involve the use of previously trusted but now compromised components.
Introducing Socket: A Proactive Approach to Supply Chain Security#
To better protect against supply chain attacks, a new approach is necessary. This is where Socket comes into play. Socket is a unique tool that is designed to detect and block supply chain attacks before they happen, turning the reactive paradigm on its head.
Socket uses a technique called "deep package inspection" to scrutinize the behavior of an open source package, detecting potential risks before they affect the end users. It operates under the assumption that all open source code may be potentially malicious and hence proactively searches for indicators of compromised packages.
This proactive approach helps to bridge the gap left by traditional security tools, ensuring a more comprehensive defense against the threats lurking in the open source ecosystem.
Beyond Traditional Vulnerability Scanners and Static Analysis Tools#
The Socket approach differs greatly from the current market offerings. Vulnerability scanners and static analysis tools have their place in a security toolchain but fail to provide comprehensive protection against supply chain attacks.
Socket, however, is uniquely positioned to offer a solution specifically tailored to combat supply chain attacks. By shifting from the traditional reactive model to a proactive approach, Socket can detect potentially malicious activities before they cause damage.
While traditional tools provide a flood of alerts, often making it difficult to identify true threats, Socket offers actionable feedback about dependency risk, allowing you to focus on the most pressing issues.
How Socket Secures the Supply Chain: Features and Functionality#
Socket offers a suite of features to combat the different aspects of supply chain attacks:
• Supply Chain Attack Prevention: It monitors changes to package.json in real-time, preventing compromised or hijacked packages from entering your supply chain.
• Detect Suspicious Package Behavior: It recognizes when dependency updates introduce new risky APIs such as network, shell, filesystem, and more.
• Comprehensive Protection: Socket is capable of blocking 70+ red flags in open source code, such as malware, typo-squatting, hidden code, misleading packages, and permission creep.
In essence, Socket strives to provide a proactive and robust line of defense against supply chain attacks, reducing the reliance on reactive methods of threat detection and mitigation.
Future Perspectives: Securing the Open Source Ecosystem#
While the rise of supply chain attacks is concerning, the proactive measures like those provided by Socket offer hope. As technology continues to evolve, so too must our approach to security.
By embracing proactive and comprehensive security measures, we can work to secure the open source ecosystem. Tools like Socket represent a significant step in the right direction, providing both a novel approach to a challenging problem and a tangible solution.
However, the job doesn't end here. Developers, open source maintainers, and security practitioners must continue to engage in creating more secure environments. With the combined efforts of everyone involved, we can make open source safer and continue to enjoy the benefits it offers without the looming threat of security breaches.
Securing our digital supply chain is a shared responsibility. With innovative tools and a collaborative effort, we can mitigate threats and pave the way for a safer open source ecosystem.
Table of Contents
Introduction to Supply Chain SecurityUnderstanding the Open Source Ecosystem and its RisksThe Growing Threat of Supply Chain AttacksCurrent Security Measures and Their LimitationsIntroducing Socket: A Proactive Approach to Supply Chain SecurityBeyond Traditional Vulnerability Scanners and Static Analysis ToolsHow Socket Secures the Supply Chain: Features and FunctionalityFuture Perspectives: Securing the Open Source Ecosystem
SocketSocket SOC 2 Logo
Product
Stay in touch
Get open source security insights delivered straight into your inbox.
• Terms
• Privacy
• Security
Made with ⚡️ by Socket Inc
|
__label__pos
| 0.725326 |
Пример предотвращения столкновений или Справка
88
12
Я пытаюсь найти пример предотвращения столкновений, который я могу адаптировать и использовать для игры, над которой я работаю. Он будет использоваться для моделирования движения лыжника, чтобы избежать деревьев на холме. Я основываю движение Offing Behaviors для автономных персонажей, и есть много хороших примеров для следования и стекания пути, но я не могу найти хороших для предотвращения столкновений. На веб-сайте Nature of Code были потрясающие руководства по рулевому управлению, но, казалось, охватывали все, кроме предотвращения препятствий.
Я преобразовал код из здесь, но он не работает так хорошо, как должен, потому что столкновений обнаруживается путем проецирования центра препятствий на вектор скорости без учета, когда центр препятствий может находиться за пределами столкновения, но круг все еще сталкивается. Вот код, который я адаптировал (написанный в разделе Обработка (на основе Java)).
// Method to update location
void update() {
// Update velocity
vel.add(acc);
// Limit speed
vel.limit(maxspeed);
loc.add(vel);
// Reset accelertion to 0 each cycle
acc.mult(0);
}
void obstacleAvoid() {
float checkLength = 30*vel.mag();
PVector forward,diff,ray,projection,force;
float dotProd,dis;
forward = vel.get();
forward.normalize();
ray = forward.get();
ray.mult(checkLength);
for ( int i = 0; i < obs.size(); i++ ) {
Obstacle ob = (Obstacle)obs.get(i);
diff = ob.pos.get();
diff.sub(loc);
PVector temp2 = forward.get();
temp2.mult(ob.r);
diff.sub(temp2);
dotProd = diff.dot(forward);
if ( dotProd > 0 ) {
projection = forward.get();
projection.mult(dotProd);
dis = PVector.dist(projection,diff);
if ( (dis < (ob.r + r)) && (projection.mag() < ray.mag()) ) {
ob.hit = true;
force = forward.get();
force.mult(maxforce);
if ( sign(diff,vel) == -1 ) { //CCW
force.set(force.y,-force.x,0);
}
else { //CW
force.set(-force.y,force.x,0);
}
force.mult(1-(projection.mag())/ray.mag());
force.limit(maxforce);
acc.add(force);
}
}
}
}
Итак, чтобы помочь мне, мне было интересно узнать, не знает ли кто-нибудь о каких-либо полных примерах предотвращения столкновений, которые следуют за принципами поведения для автономных персонажей, чтобы сделать что-то лучше. Этот сайт является примером апплета для бумаги и является точным примером, я хотел бы видеть код для. К сожалению, нет никакого кода, чтобы прийти с ним, и я попытался декомпилировать его, но он просто показал основной класс, так что это было не очень полезно. Если у кого-то есть код для этого примера или что-то в этом роде или учебник, я был бы очень признателен.
спросил(а) 2021-01-19T15:26:21+03:00 2 месяца, 3 недели назад
1
Решение
61
Craig Reynolds не может выпускать исходный код для интересующих вас апплетов. Аналогичный исходный код доступен в С++ по адресу OpenSteer, который поддерживается Рейнольдсом. Христиан Шнелльхаммер и Томас Фейлкас работали над расширением оригинальной бумаги Рейнольдса. Их статья переведена на english и содержит раздел об избежании препятствий. Исходный код для их работы доступен в Java. Тем не менее, Я думаю, что код Shiffman является отличной отправной точкой, и похоже, что вы почти близки к тому, что вы хотите уже
Одна из моих первых программ обработки изменила пример Boids, чтобы имитировать апокалипсис зомби. Треугольники преследовали круги, которые избегали их. Каждый оставшийся в живых проверяет других зомби в своем видении и усредняет координаты местоположения угроз в функции, PVector panic(ArrayList infected). После этого было связано с переносом нового вектора негативно и добавлением его к вектору тока, оставшегося в живых, как и любая другая сила. Что-то вроде:
void flock(ArrayList uninfected, ArrayList infected) {
PVector sep = separate(uninfected); // Separation
PVector ali = align(uninfected); // Alignment
PVector coh = cohesion(uninfected); // Cohesion
PVector pan = panic(infected); // Panic
// Arbitrarily weight these forces
sep.mult(4.0);
ali.mult(1.0);
coh.mult(2.0);
pan.mult(-3.0);
// Add the force vectors to acceleration
acc.add(sep);
acc.add(ali);
acc.add(coh);
acc.add(pan);
}
Если ваш лыжник успешно обнаруживает препятствия, тогда проблема избежания является проблемой. Добавляя более сильный вес к вектору избегания, увеличивая радиус, который лыжник может "видеть" для взаимодействия с объектами, или даже добавление метода к объекту, который возвращает местоположение ближайшей точки к лыжнику, может решить вашу проблему. Вы также можете добавить замедление, основанное на расстоянии от лыжника до ближайшего препятствия перед ним.
Помните, что даже апплет, который вам интересен, не позволяет избежать препятствий. Мое решение может быть не совсем тем, что происходит в апплете, но, играя с силами, определяющими ваше направление лыжника, вы можете добиться очень схожим (и, возможно, лучшим) эффектом.
ответил(а) 2021-01-19T15:26:21+03:00 2 месяца, 3 недели назад
43
Оформить эту ссылку на сайте разработки сайта NEHE:
В этом уроке вы узнаете основы обнаружения столкновений, реакция столкновения и физическая основанные на моделировании. Этот учебник больше концентрируется на том, как столкновение чем на фактических кода, хотя все важные код объясняется.
http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=30
Это делается с использованием С++ и win32 API. Хотя вы можете найти ссылку для Java Port с помощью JOGL.
И
Исходный код для http://www.red3d.com/cwr/steer/ доступен здесь http://opensteer.sourceforge.net/, хотя в С++. Вы проверили его?
ответил(а) 2021-01-19T15:26:21+03:00 2 месяца, 3 недели назад
Ваш ответ
Введите минимум 50 символов
Чтобы , пожалуйста,
Выберите тему жалобы:
Другая проблема
|
__label__pos
| 0.573634 |
Tips for better performance in Azure Cognitive Search
This article is a collection of tips and best practices that are often recommended for boosting performance. Knowing which factors are most likely to impact search performance can help you avoid inefficiencies and get the most out of your search service. Some key factors include:
• Index composition (schema and size)
• Query types
• Service capacity (tier, and the number of replicas and partitions)
Index size and schema
Queries run faster on smaller indexes. This is partly a function of having fewer fields to scan, but it's also due to how the system caches content for future queries. After the first query, some content remains in memory where it's searched more efficiently. Because index size tends to grow over time, one best practice is to periodically revisit index composition, both schema and documents, to look for content reduction opportunities. However, if the index is right-sized, the only other calibration you can make is to increase capacity: either by adding replicas or upgrading the service tier. The section "Tip: Upgrade to a Standard S2 tier" shows you how to evaluate the scale up versus scale out decision.
Schema complexity can also adversely effect indexing and query performance. Excessive field attribution builds in limitations and processing requirements. Complex types take longer to index and query. The next few sections explore each condition.
Tip: Be selective in field attribution
A common mistake that administrators and developer make when creating a search index is selecting all available properties for the fields, as opposed to only selecting just the properties that are needed. For example, if a field doesn't need to be full text searchable, skip that field when setting the searchable attribute.
Selective attribution
Support for filters, facets, and sorting can quadruple storage requirements. If you add suggesters, storage requirements go up even more. For an illustration on the impact of attributes on storage, see Attributes and index size.
Summarized, the ramifications of over-attribution include:
• Degradation of indexing performance due to the extra work required to process the content in the field, and then store it within the search inverted index (set the "searchable" attribute only on fields that contain searchable content).
• Creates a larger surface that each query has to cover. All fields marked as searchable are scanned in a full text search.
• Increases operational costs due to extra storage. Filtering and sorting requires additional space for storing original (non-analyzed) strings. Avoid setting filterable or sortable on fields that don't need it.
• In many cases, over attribution limits the capabilities of the field. For example, if a field is facetable, filterable, and searchable, you can only store 16 KB of text within a field, whereas a searchable field can hold up to 16 MB of text.
Note
Only unnecessary attribution should be avoided. Filters and facets are often essential to the search experience, and in cases where filters are used, you frequently need sorting so that you can order the results (filters by themselves return in an unordered set).
Tip: Consider alternatives to complex types
Complex data types are useful when data has a complicated nested structure, such as the parent-child elements found in JSON documents. The downside of complex types is the extra storage requirements and additional resources required to index the content, in comparison to non-complex data types.
In some cases, you can avoid these tradeoffs by mapping a complex data structure to a simpler field type, such as a Collection. Alternatively, you might opt for flattening a field hierarchy into individual root-level fields.
flattened field structure
Types of queries
The types of queries you send are one of the most important factors for performance, and query optimization can drastically improve performance. When designing queries, think about the following points:
• Number of searchable fields. Each additional searchable field requires additional work by the search service. You can limit the fields being searched at query time using the "searchFields" parameter. It's best to specify only the fields that you care about to improve performance.
• Amount of data being returned. Retrieving a lot of content can make queries slower. When structuring a query, return only those fields that you need to render the results page, and then retrieve remaining fields using the Lookup API once a user selects a match.
• Use of partial term searches. Partial term searches, such as prefix search, fuzzy search, and regular expression search, are more computationally expensive than typical keyword searches, as they require full index scans to produce results.
• Number of facets. Adding facets to queries requires aggregations for each query. Requesting a higher "count" for a facet also requires extra work by the service. In general, only add the facets that you plan to render in your app and avoid requesting a high count for facets unless necessary.
• High skip values. Setting the $skip parameter to a high value (for example, in the thousands) increases search latency because the engine is retrieving and ranking a larger volume of documents for each request. For performance reasons, it's best to avoid high $skip values and use other techniques instead, such as filtering, to retrieve large numbers of documents.
• Limit high cardinality fields. A high cardinality field refers to a facetable or filterable field that has a significant number of unique values, and as a result, consumes significant resources when computing results. For example, setting a Product ID or Description field as facetable and filterable would count as high cardinality because most of the values from document to document are unique.
Tip: Use search functions instead overloading filter criteria
As a query uses increasingly complex filter criteria, the performance of the search query will degrade. Consider the following example that demonstrates the use of filters to trim results based on a user identity:
$filter= userid eq 123 or userid eq 234 or userid eq 345 or userid eq 456 or userid eq 567
In this case, the filter expressions are used to check whether a single field in each document is equal to one of many possible values of a user identity. You are most likely to find this pattern in applications that implement security trimming (checking a field containing one or more principal IDs against a list of principal IDs representing the user issuing the query).
A more efficient way to execute filters that contain a large number of values is to use search.in function, as shown in this example:
search.in(userid, '123,234,345,456,567', ',')
Tip: Add partitions for slow individual queries
When query performance is slowing down in general, adding more replicas frequently solves the issue. But what if the problem is a single query that takes too long to complete? In this scenario, adding replicas will not help, but additional partitions might. A partition splits data across extra computing resources. Two partitions split data in half, a third partition splits it into thirds, and so forth.
One positive side-effect of adding partitions is that slower queries sometimes perform faster due to parallel computing. We have noted parallelization on low selectivity queries, such as queries that match many documents, or facets providing counts over a large number of documents. Since significant computation is required to score the relevancy of the documents, or to count the numbers of documents, adding extra partitions helps queries complete faster.
To add partitions, use Azure portal, PowerShell, Azure CLI, or a management SDK.
Service capacity
A service is overburdened when queries take too long or when the service starts dropping requests. If this happens, you can address the problem by upgrading the service or by adding capacity.
The tier of your search service and the number of replicas/partitions also have a big impact on performance. Each higher tier provides faster CPUs and more memory, both of which have a positive impact on performance.
Tip: Upgrade to a Standard S2 tier
The Standard S1 search tier is often where customers start. A common pattern for S1 services is that indexes grow over time, which requires more partitions. More partitions lead to slower response times, so more replicas are added to handle the query load. As you can imagine, the cost of running an S1 service has now progressed to levels beyond the initial configuration.
At this juncture, an important question to ask is whether it would be beneficial to move to a higher tier, as opposed to progressively increasing the number of partitions or replicas of the current service.
Consider the following topology as an example of a service that has taken on increasing levels of capacity:
• Standard S1 tier
• Index Size: 190 GB
• Partition Count: 8 (on S1, partition size is 25 GB per partition)
• Replica Count: 2
• Total Search Units: 16 (8 partitions x 2 replicas)
• Hypothetical Retail Price: ~$4,000 USD / month (assume $250 USD x 16 search units)
Suppose the service administrator is still seeing higher latency rates and is considering adding another replica. This would change the replica count from 2 to 3 and as a result change the Search Unit count to 24 and a resulting price of $6,000 USD/month.
However, if the administrator chose to move to a Standard S2 tier the topology would look like:
• Standard S2 tier
• Index Size: 190 GB
• Partition Count: 2 (on S2, partition size is 100 GB per partition)
• Replica Count: 2
• Total Search Units: 4 (2 partitions x 2 replicas)
• Hypothetical Retail Price: ~$4,000 USD / month ($1000 USD x 4 search units)
As this hypothetical scenario illustrates, you can have configurations on lower tiers that result in similar costs as if you had opted for a higher tier in the first place. However, higher tiers come with premium storage, which makes indexing faster. Higher tiers also have much more compute power, as well as extra memory. For the same costs, you could have more powerful infrastructure backing the same index.
An important benefit of added memory is that more of the index can be cached, resulting in lower search latency, and a greater number of queries per second. With this extra power, the administrator may not need to even need to increase the replica count and could potentially pay less than by staying on the S1 service.
Next steps
Review these additional articles related to service performance.
|
__label__pos
| 0.820629 |
1
回答
FlexUnit 基本应用
百度AI开发者大赛带你边学边开发，赢100万奖金，加群：418589053
FlexUnit可以说是Junit的一个复制，因为它们具有太多的相似性，不过说白了，其实所有的单元测试都是一个样，主要的方法就是通过输入来比较输出的结果是否正确。虽说原理是这么简单，但是一个好的单元测试框架，可以为编程人员带来很好的方便，在FlexUnit中，当然也有一个很有的框架。要使用FlexUnit，先须先下载FlexUnit.swc，这是一个集成的单元测试包，下载后导入即可使用。请先看看一个简单的例子：
public class MyCircle
{
private var _radiusX:int;
private var _radiusY:int;
private var _r:int;
private var _length:Number;
private var _area:Number;
public function MyCircle() {
this._r = 0;
this._radiusX = 0;
this._radiusY = 0;
this._length = 0;
this._area = 0;
}
public function get radiusX():int { return _radiusX; }
public function set radiusX(value:int):void {
_radiusX = value;
}
public function get r():int { return _r; }
public function set r(value:int):void {
_r = value;
}
public function get radiusY():int { return _radiusY; }
public function set radiusY(value:int):void {
_radiusY = value;
}
public function get length():Number {
_length = 2 * _r * Math.PI;
_length = Math.round(_length);
return _length;
}
public function get area():Number {
_area = Math.PI * _r * _r;
return _area;
}
}
我们有一个待测试的类MyCircle，现在我们要测试两个函数：get length()（周长）、get area()（面积）。为了测试，我们编写了如下的测试类：
import flexunit.framework.Assert;
import flexunit.framework.TestCase;
public class MyCircleTest extends TestCase
{
public function MyCircleTest(methodName:String) {
super(methodName);
}
public function testLength():void{
var myCircle:MyCircle = new MyCircle();
myCircle.r = 50;
var result:Number = myCircle.length;
Assert.assertEquals(result,Math.round(Math.PI * 100));
}
public function testArea():void{
var myCircle:MyCircle = new MyCircle();
myCircle.r = 50;
var result:Number = myCircle.area;
Assert.assertEquals(result,50*50*Math.PI+1);
}
}
MyCircleTest类是TestCase的一个子类，一般的情况下，我们都要继承TestCase这个类，TestCase运行多个测试方法的装置,有一个methodName的属性，表示用来测试的方法名， textLength（）、textArea（）分别的测试MyCirclelengtharea的方法。方法里，我们用到了Assert类，Assert可以说是一个用来判断结果的测试类，它提供了很多方法，如:
assertEquals（）,如何参数相等就运行正确，不等就会抛出一个错误
assertNull( ) >判断参数是否为Null;
assertUndefined( ) >判断参数是否未定义;
在一切都建立好后，再编写mxml
<?xml version="1.0"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
creationComplete="init()"
xmlns:flexui="flexunit.flexui.*"
>
<mx:Script>
<![CDATA[
import flexunit.framework.TestSuite;
import flexunit.flexui.TestRunnerBase ;
private function init():void
{
var suite:TestSuite = new TestSuite();
suite.addTest(new MyCircleTest("testLength"));
suite.addTest(new MyCircleTest("testArea"));
testRunner.test = suite;
testRunner.startTest();
}
]]>
</mx:Script>
<flexui:TestRunnerBase id="testRunner" width="100%" height="100%" />
</mx:Application>
在这里，我们定义了一个变量suite，它的类型为TestSuiteTestSuite是一个装载测试的容器，也就是说，我们的要把我们的测试类分别加到这个容器上，如:
suite.addTest( new MyCircleTest( "testLength" ) );
suite.addTest(new MyCircleTest("testArea"));
new MyCircleest(“testLength”);语句中，我们那函数testLength()的方法名作为参数，那么在TestCase里，就把methodName属性赋值为”testLength”,那么就表明了在这个TestCase对象里，我们要调用的测试方法是testLength( )
之后，我们新建一个TestRunnerBase类的实例testRunnerTestRunnerBasePanel的子类，那么它就是一个可显示的组件，它的test属性我们附值为suite，接着我们就可以开始测试了，也就调用testRunnerstartTest()函数。
上图就是我们那见到的运行结果，如果测试全面通过，即图的右方会出现“√”的符号，如果测试不通过，就会出现如图所示：
图右方的文字写出了错误的详细说明，通过它显示的数据，我们可以很清晰的看到那个类的那个方法出错，从而友好地帮助编程人员测试代码。
文章转自：http://hi.baidu.com/s_addies/blog/item/6d76ea17aa80671e972b43d8.html
举报
鉴客
发帖于7年前 1回/768阅
顶部
|
__label__pos
| 0.964076 |
We collect the most interesting free icons to provide them to you
in all popular formats and sizes
Focus icon
Focus icon
Focus icon summary
Name: Focus
Set name: Lucide
Author: Lucide
Website: https://lucide.dev/
Total : 822
Published: 2 Aug, 2022
Downloads: 0
License: ISC license
Keywords: focus focus
Tags: #focus #focus
The SVG extension (Scalable Vector Graphics) is used primarily for vector graphics and is an open format. The .SVG is based on the XML markup language, and was developed as an open standard by the World Wide Wide Consortium. The SVG format is used for both static and animated graphics.
Some of the key features of the SVG are:
• Supports hyperlinks ("XLinks")
• Support for vector shapes (such as lines, curves, etc.)
• Supports bitmap objects
• Text support
• Support for manipulation and combinations of objects, including grouping, transformations and event-based scripting
Based on XML (which is essentially a text format), SVG images compress well. SVGZ format is a modified SVG format that uses GZIP compression and thus solves the problem of large SVG file sizes.
There are several versions of the SVG format in use today (SVG 1.0, SVG 1.1, and SVG Tiny 1.2 at the time of this writing). Specifically, SVG Tiny (SVGT) and SVG Basic (SVGB) are subsets of the full SVG standard primarily intended for use on a device with disabilities such as mobile phones or PDAs. In addition, it should be noted that browser support for SVG has proven to be incomplete - currently a large number of browsers, including Internet Explorer, require an additional plugin (which many users will not have) to display the SVG image.
ICO extension - image format used to store icons in Windows programs, files and folders; contains two bitmaps: 1) AND bitmap - an image mask (which determines which part of the image is transparent) and 2) XOR bitmap - contains an image that is superimposed on the image mask, these files can be changed to create your own icons also. Icons can be of different sizes (16 × 16, 32 × 32, 64 × 64 pixels, etc.) and contain a different number of colors (16 colors, 32, 64, 128, 256, 16-bit, etc.)
The "Favicon.ico" file is used to store a small site logo that appears in the address bar of a web browser. If the site has a favion.ico, then it will appear to the left of the web address when loading any page on the site. The favicon.ico file must be 16x16 pixels and stored in the root directory of the website for the web browser to detect.
The PNG file (Portable Network Graphic) refers to bitmap images. The PNG data contains a specific palette of colors used in the drawing. Such a graphic format is quite often used in the world wide web when assigning different images to web pages. Thanks to the Deflate compression algorithm, bitmaps with the PNG file extension are available for compression without obvious quality loss.
PNG was developed to replace the GIF format, because the latter required paid software for a long time. Among the owners of web resources, PNG images are famous for their excellent characteristics against the background of such formats. PNG supports a color depth of up to 48 bits. The main difference between gifs is that such a graphic file is limited to only 8 bits (256 colors in total). You should know that unlike GIF, PNG does not support animation effects.
You can open a file with the PNG extension using virtually any viewer. In the Windows operating system, you can open PNG by simply double-clicking to view images. PNG documents are also available in any web browser. If the user needs to change the saved image in the PNG version, just use image editing tools such as Adobe Photoshop or Microsoft Windows Photos, as well as Corel PaintShop or ACD Systems.
This file extension is very popular and contains all the necessary graphic information for full-color images of good quality.
Icon%nbsp;files used on MAC computers and other OS X devices use the ICNS extension. This format is used to display a small image (icon) in OS X Finder that represents the corresponding application. ICNS files support images of various sizes. The size varies from 16x16 to 512x512 pixels. Starting with OS x Mountain Lion, ICNS files can support even large images - 1024x1024 pixels. This format supports both single-bit and eight-bit alpha channels, as well as various stages of images, including folder icons in the open and closed state.
An ICNS data usually consists of one or more PNG images. This format is very convenient as a basis for ICNS because it allows for transparency. ICNS format supports the 1-bit format, as well as 8-bit alpha channels. What distinguishes them from Windows ICO is that ICNS document able to contain separate image resources, i.e. they act more like a container.
Similar to Focus icon
Similar icons: Focus focus,
Focus focus,
Similar icons: Highlight off 24px highlight, climax, feature,
Highlight off 24px highlight, climax, feature,
Similar icons: Highlight off 48px highlight, climax, feature,
Highlight off 48px highlight, climax, feature,
Similar icons: Panel left focus right filled panel,
Panel left focus right filled panel,
Similar icons: Focus focus,
Focus focus,
Similar icons: Hub media people search social web hub, nerve center, core,
Hub media people search social web hub, nerve center, core,
Similar icons: Center focus strong 24px center, inside, interior,
Center focus strong 24px center, inside, interior,
Similar icons: Center focus strong 48px center, inside, interior,
Center focus strong 48px center, inside, interior,
Similar icons: Center focus weak 24px center, inside, interior,
Center focus weak 24px center, inside, interior,
Similar icons: Center focus weak 48px center, inside, interior,
Center focus weak 48px center, inside, interior,
Similar icons: Selected focus selected, focal point, spotlight,
Selected focus selected, focal point, spotlight,
Similar icons: Focus outlined focus,
Focus outlined focus,
Similar icons: Github hub github, nerve center, core,
Github hub github, nerve center, core,
Similar icons: Focus 2 focus,
Focus 2 focus,
Similar icons: Focus centered focus,
Focus centered focus,
Similar icons: Focus focus,
Focus focus,
Similar icons: Focus precise shot strategic tactic target focus,
Focus precise shot strategic tactic target focus,
Similar icons: Highlight 24px highlight, climax, feature,
Highlight 24px highlight, climax, feature,
Similar icons: Focus shot strategic tactic target focus,
Focus shot strategic tactic target focus,
Similar icons: Aiming aiming, address, design,
Aiming aiming, address, design,
Similar icons: Highlight 48px highlight, climax, feature,
Highlight 48px highlight, climax, feature,
Similar icons: Focus move strategic tactic together focus,
Focus move strategic tactic together focus,
Similar icons: Converging gateway converging, assemble, concentrate,
Converging gateway converging, assemble, concentrate,
Similar icons: Focus goals mission office seo target focus,
Focus goals mission office seo target focus,
Similar icons: Github hub internet network social web github, nerve center, core,
Github hub internet network social web github, nerve center, core,
Similar icons: Filter center focus 24px filter, clean, drain,
Filter center focus 24px filter, clean, drain,
Similar icons: Filter center focus 48px filter, clean, drain,
Filter center focus 48px filter, clean, drain,
Similar icons: Archery focus goal objective success target archery,
Archery focus goal objective success target archery,
Similar icons: Focus images instagram photo photography pic focus, focal point, spotlight,
Focus images instagram photo photography pic focus, focal point, spotlight,
Similar icons: Focus focus,
Focus focus,
More free icons from this set
|
__label__pos
| 0.678701 |
Difference between revisions of "Orion/Documentation/Developer Guide/Configuration services"
From Eclipsepedia
Jump to: navigation, search
(Managed Services)
(Managed Services)
Line 12: Line 12:
A Managed Service needs to receive its configuration information before the service is invoked to perform other work. For example, a configurable [[Orion/Documentation/Developer_Guide/Plugging_into_the_editor#orion.edit.validator|validation service]] would want to receive any custom validation options (or <code>null</code>, if no custom options were configured) before actually performing any validation. For this reason, the framework guarantees that a Managed Service's <code>updated()</code> method will be called prior to any other service methods the service may implement.
A Managed Service needs to receive its configuration information before the service is invoked to perform other work. For example, a configurable [[Orion/Documentation/Developer_Guide/Plugging_into_the_editor#orion.edit.validator|validation service]] would want to receive any custom validation options (or <code>null</code>, if no custom options were configured) before actually performing any validation. For this reason, the framework guarantees that a Managed Service's <code>updated()</code> method will be called prior to any other service methods the service may implement.
Managed Services can be contributed by registering against the [[#orion.cm.managedservice|orion.cm.managedservice]] service name. Every Managed Service must provide a service property named <code>"pid"</code> which gives a ''PID'' (persistent identifier). The PID serves as primary key, uniquely identifying the configuration information of a Managed Service.
+
To contribute a Managed Service, we register a service with the name <code>"[[#orion.cm.managedservice|orion.cm.managedservice]]"</code>. Every Managed Service must provide a service property named <code>"pid"</code> which gives a ''PID'' (persistent identifier). The PID serves as primary key, uniquely identifying the configuration information of a Managed Service.
The Orion concept of a Managed Service is analogous to the OSGi [http://www.osgi.org/javadoc/r4v42/org/osgi/service/cm/ManagedService.html Managed Service].
The Orion concept of a Managed Service is analogous to the OSGi [http://www.osgi.org/javadoc/r4v42/org/osgi/service/cm/ManagedService.html Managed Service].
Revision as of 16:56, 8 July 2013
Contents
Overview of configuration services
Orion provides a number of service APIs related to service configuration. This page explains the service configuration APIs. For a basic overview of Orion's service architecture, see Architecture.
Managed Services
A service may need configuration information before it can perform its intended functionality. Such services are called Managed Services. A Managed Service implements a method, updated(), which is called by the Orion configuration framework to provide configuration data to the service. As with all service methods, updated() is called asynchronously. The configuration data takes the form of a dictionary of key-value pairs, called properties. If no configuration data exists for the Managed Service, null properties are passed.
A Managed Service needs to receive its configuration information before the service is invoked to perform other work. For example, a configurable validation service would want to receive any custom validation options (or null, if no custom options were configured) before actually performing any validation. For this reason, the framework guarantees that a Managed Service's updated() method will be called prior to any other service methods the service may implement.
To contribute a Managed Service, we register a service with the name "orion.cm.managedservice". Every Managed Service must provide a service property named "pid" which gives a PID (persistent identifier). The PID serves as primary key, uniquely identifying the configuration information of a Managed Service.
The Orion concept of a Managed Service is analogous to the OSGi Managed Service.
Meta Typing
A Metatype describes the shape of configuration data*. In other words, it specifies what property names can appear in the properties dictionary, and what data types (string, boolean, number, etc) their values may have. Metatype information is defined in terms of Object Class Definitions (OCDs), which can be reused. Metatype information is associated with a Managed Service's PID. Metatype information is optional, so not every Managed Service need have Metatype information associated with it.
Metatype information can be contributed by registering a service with the orion.cm.metatype service name.
The Orion concept of a Metatype is analogous to the OSGi Metatype.
* In this page we discuss Metatype information solely in the context of configuration management. Strictly speaking, Metatypes are generic, and can be used for other purposes.
Configuration management
Configuration data is managed by a ConfigurationAdmin service, which maintains a database of Configuration objects. The ConfigurationAdmin monitors the service registry and provides configuration data to Managed Services that are registered. Orion's implementation of ConfigurationAdmin persists configuration data to a Preferences Service.
In JavaScript code, configuration information is represented as Configuration objects (refer to "orion.cm.Configuration" in the client API reference for JSDoc), which are returned by the ConfigurationAdmin's service methods. Because the ConfigurationAdmin service is currently only accessible to code running in the same window as the service registry, Configuration objects cannot be directly interacted with by external services. Managed Services can only receive configuration information via their updated() method.
The Orion ConfigurationAdmin service is analogous to the OSGi ConfigurationAdmin.
Settings
On top of the basic configuration and metatype APIs, Orion also provides a higher-level Settings API. See Plugging into the settings page for details.
orion.cm.configadmin
The orion.cm.configadmin service, also called ConfigurationAdmin, provides management of configuration information. Internally, the ConfigurationAdmin service is used by the Settings page to manage the values of plugin Settings.
The service methods are:
getConfiguration(pid)
Returns the Configuration with the given PID from the database. If no such Configuration exists, a new one is created and then returned.
listConfigurations()
Returns an array of all current Configuration objects from the database.
Refer to orion.cm.ConfigurationAdmin in the client API reference for a full description of this service's API methods.
Here is an example of how to use the ConfigurationAdmin service to print out all existing configurations and their property values:
var configurations = serviceRegistry.getService("orion.cm.configadmin").listConfigurations().then(function(configurations) {
configurations.forEach(function(configuration) {
var properties = configuration.getProperties();
var propertyInfo = Object.keys(properties).map(function(propertyName) {
if (propertyName !== "pid") {
return "\n " + propertyName + ": " + JSON.stringify(properties[propertyName]) + "\n";
}
}).join("");
console.log("Configuration pid: " + configuration.getPid() + "\n"
+ " properties: {" + propertyInfo + "\n"
+ " }");
});
});
The result might look something like this:
Configuration pid: nonnls.config
properties: {
enabled: false
}
Configuration pid: jslint.config
properties: {
options: "laxbreak:true, maxerr:50"
}
orion.cm.managedservice
Contributes a Managed Service. A Managed Service is a service that can receive configuration data.
Service properties
A Managed Service must define the following property:
pid
String Gives the PID for this Managed Service.
Service methods
A Managed Service must implement the following method:
updated(properties)
The ConfigurationAdmin invokes this method to provide configuration to this Managed Service. If no configuration exists for this Managed Service's PID, properties is null. Otherwise, properties is a dictionary containing the service's configuration data.
Examples
This minimal example shows the implementation of a plugin which registers a Managed Service under the PID "example.pid". When its updated() method is called, it simply prints out what it received:
define(["orion/plugin"], function(PluginProvider) {
var provider = new PluginProvider();
provider.registerService(["orion.cm.managedservice"],
{ pid: "example.pid"
},
{ updated: function(properties) {
if (properties === null) {
console.log("We have no properties :(");
} else {
console.log("We got properties!");
console.dir(properties);
}
}
});
provider.connect();
});
Here is a larger example, showing how a validation service (a spellchecker that checks for any occurrences of the misspelling "definately") might accept options through its configuration properties. The service implementation in this example is both a validator and a Managed Service.
define(["orion/plugin"], function(PluginProvider) {
var provider = new PluginProvider();
var options;
provider.registerService(["orion.cm.managedservice", "orion.edit.validator"],
{ pid: "example.validator",
contentType: ["text/plain"]
},
{ updated: function(properties) {
if (properties === null) {
// No configuration, use default
options = { enabled: true };
} else {
options = { enabled: !!properties.enabled };
}
},
checkSyntax: function(title, contents) {
if (!options.enabled) {
return { problems: [] };
}
var problems = [];
contents.split(/\r?\n/).forEach(function(line, i) {
var index;
if ((index = line.indexOf("definately") !== -1) {
problems.push({
description: "Misspelled word",
line: i+1,
start: index,
end: index+10,
severity: "warning"
});
}
});
return { problems: problems };
}
});
provider.connect();
});
The updated() method here checks its configuration dictionary for a boolean enabled property that determines whether the validator is active. In the case of null properties, the service uses a reasonable default. (It's a best practice for configurable services to behave sanely when no configuration has been defined for them.)
Note that, by virtue of the configuration framework's guarantee that updated() is called before all other service methods, our checkSyntax() method can safely assume that the options variable has been set.
orion.cm.metatype
The orion.cm.metatype service contributes Metatype information. Metatype information is based around Object Class Definitions (OCDs), which are first-class reusable elements. An OCD contains one or more Attribute Definitions. An Attribute Definition defines an individual property that can appear within a particular instance of the containing OCD.
The orion.cm.metatype service serves two purposes:
Object Classes are analogous to OSGi Object Class Definitions, and Attribute Definitions to OSGi Attribute Definitions. In OO terms, Object Classes are similar to classes, and Attribute Definitions are similar to fields or instance variables.
Service properties
There are two top-level properties: classes (defines an OCD), and designates (associates an OCD with a PID). Either of these properties, or both of them, may be specified.
Define an OCD
To define one or more Object Class Definitions, the classes service property is used:
classes
ObjectClass[]. Defines Object Classes. Object Classes defined here can be referenced elsewhere by their ID. Each ObjectClass element has the following shape:
id
String. Uniquely identifies this OCD.
name
String. Optional. The name of this OCD.
properties
AttributeDefinition[]. Defines the Attribute Definitions that can appear in instances of this OCD. Each AttributeDefinition element has the following shape:
id
String. The property id. This is unique within the containing OCD.
name
String. Optional. The name of this property.
type
'string' | 'number' | 'boolean'. Optional, defaults to 'string'. The data type.
defaultValue
Object. Optional, defaults to null. The default value of this property. This is a literal whose type matches the property's type.
options
PropertyOption[]. Optional, defaults to null. If nonnull, gives an enumeration of allowed values that this property can take. Each PropertyOption element has the following shape:
value
Object. The value of this option. This is a literal value whose type matches the property's type.
label
String. The label for this option.
Associate an OCD with a PID
To create PID-to-Object-Class associations, the designates service property is used:
designates
Designate[]. Each Designate element has the following shape:
pid
String. The PID for which OCD information will be associated.
classId
String. References an OCD by ID. The referenced OCD will be associated with the PID.
Object Classes are publicly visible, so the OCD referenced by a Designate element may be defined by a different Metatype service. The order in which Metatype services are registered does not matter.
Service methods
None. This service is purely declarative.
Examples
This example shows how to define an OCD with ID example.customer. The OCD has two AttributeDefinitions.
define(['orion/plugin'], function(PluginProvider) {
var pluginProvider = new PluginProvider();
pluginProvider.registerService('orion.cm.metatype',
{},
{ classes: [
{ id: 'example.customer',
properties: [
{ id: 'fullname',
name: 'Full Name',
type: 'string'
},
{ id: 'address',
name: 'Mailing Address',
type: 'string'
}
]
}
]
});
provider.connect();
});
Building on the previous example, here's how we would use a designates to associate the example.customer OCD with a PID named example.pid.
define(['orion/plugin'], function(PluginProvider) {
var pluginProvider = new PluginProvider();
pluginProvider.registerService('orion.cm.metatype',
{},
{ classes: [
{ id: 'example.customer',
properties: [
{ id: 'fullname',
name: 'Full Name',
type: 'string'
},
{ id: 'address',
name: 'Mailing Address',
type: 'string'
}
]
}
]
});
// New code starts here
pluginProvider.registerService('orion.cm.metatype',
{},
{ designates: [
{ pid: 'example.pid',
classId: 'example.customer'
}
]
});
provider.connect();
});
Alternatively, we can use a single service registration, with both classes and designates, to achieve the same effect:
define(['orion/plugin'], function(PluginProvider) {
var pluginProvider = new PluginProvider();
pluginProvider.registerService('orion.cm.metatype',
{},
{ classes: [
{ id: 'example.customer',
properties: [
{ id: 'fullname',
name: 'Full Name',
type: 'string'
},
{ id: 'address',
name: 'Mailing Address',
type: 'string'
}
]
}
],
designates: [
{ pid: 'example.pid',
classId: 'example.customer'
}
]
});
provider.connect();
});
See also
orion.core.setting
|
__label__pos
| 0.911345 |
Stack Overflow is a community of 4.7 million programmers, just like you, helping each other.
Join them; it only takes a minute:
Sign up
Join the Stack Overflow community to:
1. Ask programming questions
2. Answer and help your peers
3. Get recognized for your expertise
Suppose I was given a URL.
It might already have GET parameters (e.g. http://example.com/search?q=question) or it might not (e.g. http://example.com/).
And now I need to add some parameters to it like {'lang':'en','tag':'python'}. In the first case I'm going to have http://example.com/search?q=question&lang=en&tag=python and in the second — http://example.com/search?lang=en&tag=python.
Is there any standard way to do this?
share|improve this question
11 Answers 11
up vote 89 down vote accepted
There are couple quirks with urllib and urlparse modules. Here's working example:
try:
import urlparse
from urllib import urlencode
except: # For Python 3
import urllib.parse as urlparse
from urllib.parse import urlencode
url = "http://stackoverflow.com/search?q=question"
params = {'lang':'en','tag':'python'}
url_parts = list(urlparse.urlparse(url))
query = dict(urlparse.parse_qsl(url_parts[4]))
query.update(params)
url_parts[4] = urlencode(query)
print(urlparse.urlunparse(url_parts))
share|improve this answer
7
You probably want to use urlparse.parse_qs instead of parse_qsl. The latter returns a list whereas you want a dict. See docs.python.org/library/urlparse.html#urlparse.parse_qs. – Florian Brucker Jun 6 '12 at 9:01
7
@florian : At least in python 2.7 you then need to call urlencode as urllib.urlencode(query, doseq=True). Otherwise, parameters that existed in the original url are not preserved correctly (because they are returned as tuples from @parse_qs@ – rluba Sep 11 '12 at 10:17
1
I've rewritten this to work in Python 3 as well. Code here. – duality_ Jan 22 at 11:48
2
The results of urlparse() and urlsplit() are actually namedtuple instances. Thus you can assign them directly to a variable and use url_parts = url_parts._replace(query = …) to update it. – Feuermurmel Apr 5 at 14:08
You want to use URL encoding if the strings can have arbitrary data (for example, characters such as ampersands, slashes, etc. will need to be encoded).
Check out urllib.urlencode:
>>> import urllib
>>> urllib.urlencode({'lang':'en','tag':'python'})
'lang=en&tag=python'
share|improve this answer
Why
I've been not satisfied with all the solutions on this page (come on, where is our favorite copy-paste thing?) so I wrote my own based on answers here. It tries to be complete and more Pythonic. I've added a handler for dict and bool values in arguments to be more consumer-side (JS) friendly, but they are yet optional, you can drop them.
How it works
Test 1: Adding new arguments, handling Arrays and Bool values:
url = 'http://stackoverflow.com/test'
new_params = {'answers': False, 'data': ['some','values']}
add_url_params(url, new_params) == \
'http://stackoverflow.com/test?data=some&data=values&answers=false'
Test 2: Rewriting existing args, handling DICT values:
url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}
add_url_params(url, new_params) == \
'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'
Talk is cheap. Show me the code.
Code itself. I've tried to describe it in details:
from json import dumps
try:
from urllib import urlencode, unquote
from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
# Python 3 fallback
from urllib.parse import (
urlencode, unquote, urlparse, parse_qsl, ParseResult
)
def add_url_params(url, params):
""" Add GET params to provided URL being aware of existing.
:param url: string of target URL
:param params: dict containing requested params to be added
:return: string with updated URL
>> url = 'http://stackoverflow.com/test?answers=true'
>> new_params = {'answers': False, 'data': ['some','values']}
>> add_url_params(url, new_params)
'http://stackoverflow.com/test?data=some&data=values&answers=false'
"""
# Unquoting URL first so we don't loose existing args
url = unquote(url)
# Extracting url info
parsed_url = urlparse(url)
# Extracting URL arguments from parsed URL
get_args = parsed_url.query
# Converting URL arguments to dict
parsed_get_args = dict(parse_qsl(get_args))
# Merging URL arguments dict with new params
parsed_get_args.update(params)
# Bool and Dict values should be converted to json-friendly values
# you may throw this part away if you don't like it :)
parsed_get_args.update(
{k: dumps(v) for k, v in parsed_get_args.items()
if isinstance(v, (bool, dict))}
)
# Converting URL argument to proper query string
encoded_get_args = urlencode(parsed_get_args, doseq=True)
# Creating new parsed result object based on provided with new
# URL arguments. Same thing happens inside of urlparse.
new_url = ParseResult(
parsed_url.scheme, parsed_url.netloc, parsed_url.path,
parsed_url.params, encoded_get_args, parsed_url.fragment
).geturl()
return new_url
Please be aware that there may be some issues, if you'll find one please let me know and we will make this thing better
share|improve this answer
Perhaps add a try except with from urllib.parse to include Python 3 support? Thanks for the snippet, very useful! – MattV Jul 29 '15 at 14:01
@MattV thanks, I've updated to support Python 3 :) – Sapphire64 Nov 17 '15 at 20:58
You can also use the furl module https://github.com/gruns/furl
>>> from furl import furl
>>> print furl('http://example.com/search?q=question').add({'lang':'en','tag':'python'}).url
http://example.com/search?q=question&lang=en&tag=python
share|improve this answer
Yes: use urllib.
From the examples in the documentation:
>>> import urllib
>>> params = urllib.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
>>> f = urllib.urlopen("http://www.musi-cal.com/cgi-bin/query?%s" % params)
>>> print f.geturl() # Prints the final URL with parameters.
>>> print f.read() # Prints the contents
share|improve this answer
Can you please give some brief example? – z4y4ts Mar 24 '10 at 9:11
f.read() will show you the HTML page. To see the calling url, f.geturl() – ccheneson Mar 24 '10 at 9:20
@ccheneson: Thanks, added. – unwind Mar 24 '10 at 9:22
3
-1 for using a HTTP request for parsing a URL (which is actually basic string manipulation). Plus the actual problem is not considered, because you need to know how the URL looks like to be able to append the query string correctly. – poke Mar 24 '10 at 10:11
Either the author edited question either this answer is not related to it. – simplylizz Feb 27 '13 at 17:20
Use the various urlparse functions to tear apart the existing URL, urllib.urlencode() on the combined dictionary, then urlparse.urlunparse() to put it all back together again.
Or just take the result of urllib.urlencode() and concatenate it to the URL appropriately.
share|improve this answer
I liked Łukasz version, but since urllib and urllparse functions are somewhat awkward to use in this case, I think it's more straightforward to do something like this:
params = urllib.urlencode(params)
if urlparse.urlparse(url)[4]:
print url + '&' + params
else:
print url + '?' + params
share|improve this answer
1
How about .query instead of [4] ? – Debby Mendez Mar 19 '15 at 17:10
Yet another answer:
def addGetParameters(url, newParams):
(scheme, netloc, path, params, query, fragment) = urlparse.urlparse(url)
queryList = urlparse.parse_qsl(query, keep_blank_values=True)
for key in newParams:
queryList.append((key, newParams[key]))
return urlparse.urlunparse((scheme, netloc, path, params, urllib.urlencode(queryList), fragment))
share|improve this answer
In python 2.5
import cgi
import urllib
import urlparse
def add_url_param(url, **params):
n=3
parts = list(urlparse.urlsplit(url))
d = dict(cgi.parse_qsl(parts[n])) # use cgi.parse_qs for list values
d.update(params)
parts[n]=urllib.urlencode(d)
return urlparse.urlunsplit(parts)
url = "http://stackoverflow.com/search?q=question"
add_url_param(url, lang='en') == "http://stackoverflow.com/search?q=question&lang=en"
share|improve this answer
Here is how I implemented it.
import urllib
params = urllib.urlencode({'lang':'en','tag':'python'})
url = ''
if request.GET:
url = request.url + '&' + params
else:
url = request.url + '?' + params
Worked like a charm. However, I would have liked a more cleaner way to implement this.
Another way of implementing the above is put it in a method.
import urllib
def add_url_param(request, **params):
new_url = ''
_params = dict(**params)
_params = urllib.urlencode(_params)
if _params:
if request.GET:
new_url = request.url + '&' + _params
else:
new_url = request.url + '?' + _params
else:
new_url = request.url
return new_ur
share|improve this answer
Based on this answer, one-liner for simple cases (Python 3 code):
from urllib.parse import urlparse, urlencode
url = "http://stackoverflow.com/search?q=question"
params = {'lang':'en','tag':'python'}
url += ('&' if urlparse(url).query else '?') + urlencode(params)
or:
url += ('&', '?')[urlparse(url).query == ''] + urlencode(params)
share|improve this answer
Your Answer
discard
By posting your answer, you agree to the privacy policy and terms of service.
Not the answer you're looking for? Browse other questions tagged or ask your own question.
|
__label__pos
| 0.989248 |
Cody
Problem 1024. Doubling elements in a vector
Solution 1898411
Submitted on 12 Aug 2019 by John Johni
This solution is locked. To view this solution, you need to provide a solution of the same size or smaller.
Test Suite
Test Status Code Input and Output
1 Pass
x = 1; y_correct = [1 1]; assert(isequal(your_fcn_name(x),y_correct))
t = 1 B = 1 t = 2 B = 1 1 t = 3
2 Pass
x = [0 -1 1 0 0 0 1 2]; y_correct = [0 0 -1 -1 1 1 0 0 0 0 0 0 1 1 2 2]; assert(isequal(your_fcn_name(x),y_correct))
t = 1 B = 0 t = 2 B = 0 0 t = 3 B = 0 0 -1 t = 4 B = 0 0 -1 -1 t = 5 B = 0 0 -1 -1 1 t = 6 B = 0 0 -1 -1 1 1 t = 7 B = 0 0 -1 -1 1 1 0 t = 8 B = 0 0 -1 -1 1 1 0 0 t = 9 B = 0 0 -1 -1 1 1 0 0 0 t = 10 B = 0 0 -1 -1 1 1 0 0 0 0 t = 11 B = 0 0 -1 -1 1 1 0 0 0 0 0 t = 12 B = 0 0 -1 -1 1 1 0 0 0 0 0 0 t = 13 B = 0 0 -1 -1 1 1 0 0 0 0 0 0 1 t = 14 B = 0 0 -1 -1 1 1 0 0 0 0 0 0 1 1 t = 15 B = 0 0 -1 -1 1 1 0 0 0 0 0 0 1 1 2 t = 16 B = 0 0 -1 -1 1 1 0 0 0 0 0 0 1 1 2 2 t = 17
Suggested Problems
More from this Author2
Community Treasure Hunt
Find the treasures in MATLAB Central and discover how the community can help you!
Start Hunting!
|
__label__pos
| 0.992291 |
Highlighted
Cadet
Cadet
• 26 Views
BRMS setup - guidance needed
I am trying to setup BRMS, however the rules do not get hit.
I have create a set of data models and rules. I am trying to send APIs request for testing and getting back only nulls in the fields i am trying to set.
setup screenshots are here https://access.redhat.com/discussions/5191941
request api:
curl --location --request POST 'http://localhost:8080/kie-server/services/rest/server/containers/instances/loan-application_1.1.0' \
--header 'Authorization: Basic ZG1BZG1pbjpyZWRoYXRkbTEh' \
--header 'Content-Type: application/json' \
--data-raw '{
"lookup": "default-stateless-ksession",
"commands": [
{
"insert": {
"object": {
"com.redhat.demos.dm.loan.model.Applicant": {
"creditScore": 230,
"name": "Jim Whitehurst"
}
},
"out-identifier": "applicant"
}
},
{
"insert": {
"object": {
"com.redhat.demos.dm.loan.model.Loan": {
"amount": 2500,
"approved": false,
"duration": 24,
"interestRate": 1.5
}
},
"out-identifier": "loan"
}
},
{
"fire-all-rules": {}
}
]
}'
response api:
{
"type" : "SUCCESS",
"msg" : "Container loan-application_1.1.0 successfully called.",
"result" : {
"execution-results" : {
"results" : [ {
"value" : {"com.redhat.demos.dm.loan.model.Loan":{
"amount" : 2500,
"duration" : 24,
"interestRate" : 1.5,
"approved" : true,
"reason" : "Congratulation your loan is approved!"
}},
"key" : "loan"
}, {
"value" : {"com.redhat.demos.dm.loan.model.Applicant":{
"name" : "Jim Whitehurst",
"creditScore" : 230
}},
"key" : "applicant"
} ],
"facts" : [ {
"value" : {"org.drools.core.common.DefaultFactHandle":{
"external-form" : "0:2:1433454381:1433454381:2Smiley Very HappyEFAULT:NON_TRAIT:com.redhat.demos.dm.loan.model.Loan"
}},
"key" : "loan"
}, {
"value" : {"org.drools.core.common.DefaultFactHandle":{
"external-form" : "0:1:2063239414:2063239414:1Smiley Very HappyEFAULT:NON_TRAIT:com.redhat.demos.dm.loan.model.Applicant"
}},
"key" : "applicant"
} ]
}
}
}
Labels (2)
0 Kudos
Join the discussion
You must log in to join this conversation.
|
__label__pos
| 0.990825 |
You copied the Doc URL to your clipboard.
SQDECP (vector)
Signed saturating decrement vector by count of true predicate elements.
Counts the number of true elements in the source predicate and then uses the result to decrement all destination vector elements. The results are saturated to the element signed integer range.
The predicate size specifier may be omitted in assembler source code, but this is deprecated and will be prohibited in a future release of the architecture.
313029282726252423222120191817161514131211109876543210
00100101size1010101000000PmZdn
DU
SVE
SQDECP <Zdn>.<T>, <Pm>.<T>
if !HaveSVE() then UNDEFINED;
if size == '00' then UNDEFINED;
integer esize = 8 << UInt(size);
integer m = UInt(Pm);
integer dn = UInt(Zdn);
boolean unsigned = FALSE;
Assembler Symbols
<Zdn>
Is the name of the source and destination scalable vector register, encoded in the "Zdn" field.
<T> Is the size specifier, encoded in size:
size <T>
00 RESERVED
01 H
10 S
11 D
<Pm>
Is the name of the source scalable predicate register, encoded in the "Pm" field.
Operation
CheckSVEEnabled();
integer elements = VL DIV esize;
bits(VL) operand1 = Z[dn];
bits(PL) operand2 = P[m];
bits(VL) result;
integer count = 0;
for e = 0 to elements-1
if ElemP[operand2, e, esize] == '1' then
count = count + 1;
for e = 0 to elements-1
integer element = Int(Elem[operand1, e, esize], unsigned);
(Elem[result, e, esize], -) = SatQ(element - count, esize, unsigned);
Z[dn] = result;
Operational information
This instruction might be immediately preceded in program order by a MOVPRFX instruction. The MOVPRFX instruction must conform to all of the following requirements, otherwise the behavior of the MOVPRFX and this instruction is unpredictable:
• The MOVPRFX instruction must be unpredicated.
• The MOVPRFX instruction must specify the same destination register as this instruction.
• The destination register must not refer to architectural register state referenced by any other source operand register of this instruction.
|
__label__pos
| 0.767607 |
Guide to Counting Cells Not Equal to a Specific Value in Excel
In this step-by-step guide, we will learn how to count cells that are not equal to a specific value in Excel. This is a useful skill for a variety of tasks, such as filtering data, identifying outliers, and calculating statistics.
Using the COUNTIF function
The COUNTIF function is a versatile tool that can be used to count cells that meet a specific criteria. To count cells that are not equal to a specific value, we can use the following formula:
=COUNTIF(range,”<>value”)
Here’s how it works:
• range is the range of cells that we want to count.
• value is the specific value that we want to exclude.
• The <> symbol means “not equal to”.
For example, the following formula would count the number of cells in the range A1:A10 that are not equal to “0”:
=COUNTIF(A1:A10,”<>0″)
countif not equal to
Using the SUMPRODUCT function
The SUMPRODUCT function can also be used to count cells that are not equal to a specific value. However, it is a more complex function and is not as intuitive to use as the COUNTIF function.
The syntax for the SUMPRODUCT function is as follows:
=SUMPRODUCT(array1,array2)
• array1 is the first array of values.
• array2 is the second array of values.
The SUMPRODUCT function returns the sum of the products of the corresponding elements in the two arrays. In other words, it multiplies each element in the first array with the corresponding element in the second array and then sums the products.
See also Inserting an Excel Spreadsheet into PowerPoint
To use the SUMPRODUCT function to count cells that are not equal to a specific value, we can use the following formula:
=SUMPRODUCT(–(range<>value))
Here’s how it works:
• range is the range of cells that we want to count.
• value is the specific value that we want to exclude.
• The -() operator negates the values in the range. This means that the formula will count the number of cells that are not equal to zero.
Using the COUNTIFS function
The COUNTIFS function is a more powerful function than the COUNTIF function because it can be used to count cells that meet multiple criteria. To count cells that are not equal to a specific value, we can use the following formula:
=COUNTIFS(range,”<>value”)
Here’s how it works:
• range is the range of cells that we want to count.
• value is the specific value that we want to exclude.
For example, the following formula would count the number of cells in the range A1:A10 that are not equal to “0” and not equal to “1”:
=COUNTIFS(A1:A10,”<>0″,”<>1″)
|
__label__pos
| 0.999726 |
Questions: 850
Free Answers by our Experts: 593
Many students face the C# problems while studying the programming languages. They try to solve all of them themselves but at the end they usually come to grief. They have more and more C# questions left without an answer. That’s the moment when the best thing to do is to address your C# problems to our helping center and finally calm down. We will provide you with the C# answers in the shortest period of time and promise that they will be of the highest quality. Don’t be in despair anymore – let us find solutions for your C# problems!
Ask Your question
Need a fast expert's response?
Submit order
and get a quick answer at the best price
for any assignment or question with DETAILED EXPLANATIONS!
Search & Filtering
There is an int variable that stores a certain amount of time in seconds. I need a function that converts seconds to days, hours, minutes and seconds and returns this as a string.
Write a function that will merge the contents of two sorted (ascending order)
arrays of type double values, storing the result in an array output parameter
(still in ascending order). The function should not assume that both its input
parameter arrays are the same length but can assume that one array does not
contain two copies of the same value. The result array should also contain no
duplicate values.
Hint: When one of the input arrays has been exhausted, do not forget to copy
the remaining data in the other array into the result array.
Test your function with cases in which (1) the first array is exhausted first, (2) the second array is exhausted first, and (3) the two arrays are exhausted at the same time (i.e., they end with the same value). Remember that the arrays input to this function
must already be sorted .
The University of Namibia is having its annual Cookie Fund Raiser event. Students sell boxes of the following five types of cookies: Chunky Chocolate, Macadamia, Peanut Butter, Smickerdoodle and Sugar. The VC wants an application that allows him to enter the number of boxes of each cookie type sold by each student. The application’s interface should provide a list box for selecting the cookie type and a text box for entering the number of boxes sold. The application should use a five element one-dimensional array to accumulate the number of boxes sold for each cookie type, and then display that information in label controls in the interface.
Design a C# GUI Movies Club Application that will take as an input the number of Item Ordered for DVD’s and Bluray’s then select if it is to buy or rent. the application calculates and display the total cost for the transaction before Tax, display the taxes and total after tax as well.
Note: Use the Currency Format for all money outputs and assume that the tax rate is 8.75%.
The DVD and Bluray’s cost are based on the following criteria:
Items Buy Rent
DVD’s less than 5 Items $15 $6
DVD’s 5 or more items $12 $4
Bluray’s less than 5 Items $20 $8
Bluray’s 5 or more items $16 $5
Find solutions for your homework
engineeringcomputer sciencecomputer science questions and answersIn This Project, You Will Be Asked To Implement An Electronic Warehouse That Keeps Track Of ...
Question: In This Project, You Will Be Asked To Implement An Electronic Warehouse That Keeps Track Of The Products Stored In The Storage. For Each Of The Products, The Following Data Are Common. • Product ID. • Product Name. • Product Description. • Product Price. You Will Be Asked To Implement Two Types Of Products. • Dimensional Products. • Weighted ...
This problem has been solved!
See the answer
In this project, you will be asked to implement an electronic warehouse that keeps track of the products stored in the storage. For each of the products, the following data are common. Product ID. Product Name. • Product De
How do I create a windows application named wallpaper App that calculates the number of single rolls of wallpaper required to cover a room .It must consist of four comboboxes(length(feet),Width(feet),height(feet) with the range of 10-30 for all three of them,Roll coverage(sqrFt) with the range of 40-50.Use a sub procedure to make the calculation on the calculate button,the number of the single roll should be displayed as an interger.if the roll coverage is 45,5sqrFt and the length and width and height of the room is 15,18 and 20 then the number of single roll is 30.single roll should be displayed in a text box and the app consists of two buttons calculate and exit
Task 5: Calculate number of days since the Independence Day
Write a function num_indep_days() which computes the number of days elapsed since 14th August 1947 to the date provided as input to the function. Remember that February of each leap year has 29 days! The function prototype is given below:
int num_indep_days(int day, int month, int year)
A large Internet merchandise provider determines its shipping charges based on
the number of items purchased. As the number increases, the shipping charges
proportionally decrease. This is done to encourage more purchases. If a single
item is purchased the shipping charge is $2.99. When customers purchase
between 2 and 5 items, they are charged the initial $2.99 for the first item and
then $1.99 per item for the remaining items. For customers who purchase more
than 5 items but less than 15, they are charged the initial $2.99 for the first item,
$1.99 per item for items 2 through 5, and $1.49 per item for the remaining items.
If they purchase 15 or more items, they are charged the initial $2.99 for the first
item, $1.99 per item for items 2 through 5, and $1.49 per item for items 6
through 14 and then just $0.99 per item for the remaining items. Allow the user
to enter the number of items purchased. Display the shipping charges.
Create a class called time that has separate int member data for hours, minutes, and seconds. One constructor should initialize this data to 0, and another should initialize it to fixed values. Another member function should display it, in 11:59:59 format. The final member function should add two objects of type time passed as arguments. A main() program should create two initialized time objects (should they be const?) and one that isn’t initialized. Then it should add the two initialized values together, leaving the result in the third time variable. Finally it should display the value of this third variable. Make appropriate member functions const.
LATEST TUTORIALS
New on Blog
APPROVED BY CLIENTS
|
__label__pos
| 0.50478 |
Wednesday, October 01, 2014
BROWN: Ready to start listening again?
By LINDA BROWN, Hold Me up a Little Longer, Lord | 12/4/2013
The No. 1 son was here last week. His visit, and the assorted sundry of other family and friends gathered to see him, put my brain in a serious state of high alert. He typically is able to only make the 800-mile trip once a year, and I try to memorize and treasure every moment. Later, after the dust settles, I pull out my memories one at a time and live the visit all over again.
I know technology has made this world efficient beyond imagination. Things would no doubt be slower and less advanced, not to mention the labor required to actually have a conversation or written communication without the abbreviated language of texting and tweeting. However, as Ralph Waldo Emerson once said, “For everything you have missed, you have gained something else, and for everything you gain, you lose something else.”
The No. 1 son was here last week. His visit, and the assorted sundry of other family and friends gathered to see him, put my brain in a serious state of high alert. He typically is able to only make the 800-mile trip once a year, and I try to memorize and treasure every moment. Later, after the dust settles, I pull out my memories one at a time and live the visit all over again.
I know technology has made this world efficient beyond imagination. Things would no doubt be slower and less advanced, not to mention the labor required to actually have a conversation or written communication without the abbreviated language of texting and tweeting. However, as Ralph Waldo Emerson once said, “For everything you have missed, you have gained something else, and for everything you gain, you lose something else.”
So, what have we lost to our smartphones, tablets and laptop computers?
I hear many of you shouting, “We’ve lost nothing; we’ve only gained! Look at all the people I can stay constantly connected to.”
Ahh, connectivity ... yes, that’s important, but how many times when you’re connecting with someone else are you really disconnecting with the person in front of you?
How often do you text someone about Uncle Phil telling his “When I was a boy ... ” story; the same story he tells every time two or more gather together.
Aren’t you, in fact, disconnecting Uncle Phil in order to connect with someone else?
Remember when family dinners, or even dinner dates, meant a time of sharing and looking at each other instead of glancing down at the cell phone placed where the fork was when you sat down?
I was flipping through a magazine last week and happened on a spread of beautiful dining room tables all dressed up for Thanksgiving dinner. One hostess had even incorporated small silver easels at each place setting for her guests to “park” their cell phones so they wouldn’t need to lay flat on the table and be subject to spills or mishaps.
Emails are quick and easy, not to mention free, but to open a real piece of mail — a handwritten thank you note or thinking of you message — is on a completely different plane. For starters, it takes some effort on the sender’s part and that in itself makes it even more special.
Being asked out on a date via email or text protects you from the embarrassment of rejection, but doing so in person takes guts and makes you stronger. It also allows you to see a woman smile or a boy become closer to a man.
As we continue to build technology, are we also building character or are we losing our ability to really connect on a personal level? Are we saving time and energy or are we losing important moments?
Four-year-old Bella was sitting on her Uncle Gabe’s lap while he was here, reading him one of her favorite story books. I was watching and could have predicted what eventually happened. Bella glanced up at Gabe and saw him fiddling with his smartphone. She turned the book over and laid it across her legs and folded her arms. After about a minute, Gabe noticed she was no longer reading and looked at her and said, “Start reading.” She looked back at him and said, “Start listening.”
Technology is important, but so is preserving part of what our grandparents’ generation did so well — capturing moments that change lives, that define who we are, and that teach us how to be the best people we can be.
My grandma used to tell me that if she could have just one more day with the love of her life she wouldn’t waste a single second. I fear many of us today waste much more than that.
Linda Brown is marketing director for The Ottawa Herald. Email her at [email protected]
comments powered by Disqus
|
__label__pos
| 0.596248 |
Websearch.simplespeedy.info
What is Websearch.simplespeedy.info?
Websearch.simplespeedy.info is a browser hijacker that will enter your computer uninvited. It will change your browser settings and will constantly expose you to potentially corrupted content. You should not tolerate Websearch.simplespeedy.info because this browser hijacker can lead to serious computer infections. What’s more, the hijacker’s presence may mean that you have far more unwanted applications installed. The problem is that such security threats seldom get distributed alone, so when you get around to remove Websearch.simplespeedy.info from your system, make sure you terminate other unnecessary programs as well. Your system security should be your utmost priority!test 100% FREE spyware scan and
tested removal of Websearch.simplespeedy.info*
Where does Websearch.simplespeedy.info come from?
Websearch.simplespeedy.info is a browser hijacker so you cannot download it from its immediate source directly. The hijacker’s setup file is usually included in third-party installers that are distributed in unreliable websites. For example, researchers say that most of the time users get infected with Websearch.simplespeedy.info when they download fake Flash or Java updates. This only proves that you should download programs and updates only from their official vendor’s websites.
What’s more, Websearch.simplespeedy.info is clearly not a new player in the field. It is yet another clone of the previously released hijackers from the so-called “Websearch” group. As such, Websearch.simplespeedy.info is identical to Websearch.searchoholic.info, Websearch.fixsearch.info, Websearch.calcitapp.info, and many others. Consequently, we know exactly what to expect from this hijacker because we know its origins.
What does Websearch.simplespeedy.info do?
It is obvious that this browser hijacker changes your default homepage and search engine to Websearch.simplespeedy.info. While you can still use whatever search engine you prefer, from time to time you will be forced to submit your search queries via Websearch.simplespeedy.info. Take note that this browser hijacker uses a customized version of the Google search engine.
Therefore, you should come to a conclusion that there is no use to keep Websearch.simplespeedy.infoon your computer. Why would you use a customized version of a popular search engine, if you can access its page directly?
On top of that, we have to emphasize that Websearch.simplespeedy.info displays customized search results and a lot of sponsored commercial links. You have probably noticed already that there is a flash advertisement right below the search box. You will do yourself a favor if you do not click it.
Browser hijackers and adware programs do not review what kind of content gets embedded into third-party ads. Consequently, Websearch.simplespeedy.info could be used even as malware distribution tool by cyber criminals.
How do I remove Websearch.simplespeedy.info?
To avoid such potential security threats, you need to remove Websearch.simplespeedy.info from your system. Uninstall any unwanted applications via Control Panel and restore your browser settings to delete Websearch.simplespeedy.info from your browser. Do not forget that the best way to ensure all malicious applications have been terminated for good is to run a full system scan with the SpyHunter free scanner. Do it today and save yourself the trouble of dealing with malicious infections later on.
Reset browser settings to default
Internet Explorer
1. Press Alt+T and click Internet options.
2. Open the Advanced tab and click the Reset button.
3. Mark the Delete personal settings option and press Reset.
4. Click Close.
Mozilla Firefox
1. Press Alt+H and go to Troubleshooting information.
2. Click Reset Firefox on a new tab.
3. Press Reset Firefox on the confirmation box.
Google Chrome
1. Press Alt+F and go to Settings.
2. Scroll down to the bottom and click Show advanced settings.
3. Scroll down and click the Reset browser settings button.
4. Press Reset on the confirmation box. 100% FREE spyware scan and
tested removal of Websearch.simplespeedy.info*
Disclaimer
Disclaimer
Leave a Comment
Enter the numbers in the box to the right *
|
__label__pos
| 0.806001 |
#define _GNU_SOURCE #include #include #include #include "libc.h" /* open addressing hash table with 2^n table size quadratic probing is used in case of hash collision tab indices and hash are size_t after resize fails with ENOMEM the state of tab is still usable with the posix api items cannot be iterated and length cannot be queried */ #define MINSIZE 8 #define MAXSIZE ((size_t)-1/2 + 1) struct elem { ENTRY item; size_t hash; }; struct __tab { struct elem *elems; size_t mask; size_t used; }; static struct hsearch_data htab; int __hcreate_r(size_t, struct hsearch_data *); void __hdestroy_r(struct hsearch_data *); int __hsearch_r(ENTRY, ACTION, ENTRY **, struct hsearch_data *); static size_t keyhash(char *k) { unsigned char *p = (void *)k; size_t h = 0; while (*p) h = 31*h + *p++; return h; } static int resize(size_t nel, struct hsearch_data *htab) { size_t newsize; size_t i, j; struct elem *e, *newe; struct elem *oldtab = htab->__tab->elems; struct elem *oldend = htab->__tab->elems + htab->__tab->mask + 1; if (nel > MAXSIZE) nel = MAXSIZE; for (newsize = MINSIZE; newsize < nel; newsize *= 2); htab->__tab->elems = calloc(newsize, sizeof *htab->__tab->elems); if (!htab->__tab->elems) { htab->__tab->elems = oldtab; return 0; } htab->__tab->mask = newsize - 1; if (!oldtab) return 1; for (e = oldtab; e < oldend; e++) if (e->item.key) { for (i=e->hash,j=1; ; i+=j++) { newe = htab->__tab->elems + (i & htab->__tab->mask); if (!newe->item.key) break; } *newe = *e; } free(oldtab); return 1; } int hcreate(size_t nel) { return __hcreate_r(nel, &htab); } void hdestroy(void) { __hdestroy_r(&htab); } static struct elem *lookup(char *key, size_t hash, struct hsearch_data *htab) { size_t i, j; struct elem *e; for (i=hash,j=1; ; i+=j++) { e = htab->__tab->elems + (i & htab->__tab->mask); if (!e->item.key || (e->hash==hash && strcmp(e->item.key, key)==0)) break; } return e; } ENTRY *hsearch(ENTRY item, ACTION action) { ENTRY *e; __hsearch_r(item, action, &e, &htab); return e; } int __hcreate_r(size_t nel, struct hsearch_data *htab) { int r; htab->__tab = calloc(1, sizeof *htab->__tab); if (!htab->__tab) return 0; r = resize(nel, htab); if (r == 0) { free(htab->__tab); htab->__tab = 0; } return r; } weak_alias(__hcreate_r, hcreate_r); void __hdestroy_r(struct hsearch_data *htab) { if (htab->__tab) free(htab->__tab->elems); free(htab->__tab); htab->__tab = 0; } weak_alias(__hdestroy_r, hdestroy_r); int __hsearch_r(ENTRY item, ACTION action, ENTRY **retval, struct hsearch_data *htab) { size_t hash = keyhash(item.key); struct elem *e = lookup(item.key, hash, htab); if (e->item.key) { *retval = &e->item; return 1; } if (action == FIND) { *retval = 0; return 0; } e->item = item; e->hash = hash; if (++htab->__tab->used > htab->__tab->mask - htab->__tab->mask/4) { if (!resize(2*htab->__tab->used, htab)) { htab->__tab->used--; e->item.key = 0; *retval = 0; return 0; } e = lookup(item.key, hash, htab); } *retval = &e->item; return 1; } weak_alias(__hsearch_r, hsearch_r);
|
__label__pos
| 0.99922 |
Forum
Number Of Page View:100,000+/Months
LOGIN |New User
Reply
What is the difference between #include <file> and #include ?file?
In C we can include file in program using 2 type:
1.#include<file>
2.#include?file?
1.#include<file>:In this which file we want to include surrouded by angled brakets(< >).In this method preprocessor directory search the file in the predefined default location.For instance,we have given include variable
INCLUDE=C:COMPILERINCLUDE;S:SOURCEHEADERS;
In this compiler first checks the C:COMPILERINCLUDE directory for given file.When there it is not found compiler checked the S:SOURCEHEADERS directory.If file is not found there also than it checked the current directory.
#include<file> method is used to include STANDARDHEADERS, like:stdio.h,stdlib.h.
2.#include?file?:In this which file we want to include surrouded by quotation marks(" ").In this method preprocessor directory search the file in the current location.For instance,we have given include variable
INCLUDE=C:COMPILERINCLUDE;S:SOURCEHEADERS;
In this compiler first checks the current directory.If there it is not found than it checks
C:COMPILERINCLUDE directory for given file.When there it is not found compiler,than checked the S:SOURCEHEADERS directory.
#include?file?method is used to include NON-STANDARDHEADERS.These are those header files that created by programmers for use .
|
__label__pos
| 0.999328 |
.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.32 .\" .\" Standard preamble: .\" ======================================================================== .de Sh \" Subsection heading .br .if t .Sp .ne 5 .PP \fB\\$1\fR .PP .. .de Sp \" Vertical space (when we can't use .PP) .if t .sp .5v .if n .sp .. .de Vb \" Begin verbatim text .ft CW .nf .ne \\$1 .. .de Ve \" End verbatim text .ft R .fi .. .\" Set up some character translations and predefined strings. \*(-- will .\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left .\" double quote, and \*(R" will give a right double quote. \*(C+ will .\" give a nicer C++. Capital omega is used to do unbreakable dashes and .\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, .\" nothing in troff, for use with C<>. .tr \(*W- .ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' .ie n \{\ . ds -- \(*W- . ds PI pi . if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch . if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch . ds L" "" . ds R" "" . ds C` "" . ds C' "" 'br\} .el\{\ . ds -- \|\(em\| . ds PI \(*p . ds L" `` . ds R" '' 'br\} .\" .\" If the F register is turned on, we'll generate index entries on stderr for .\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index .\" entries marked with X<> in POD. Of course, you'll have to process the .\" output yourself in some meaningful fashion. .if \nF \{\ . de IX . tm Index:\\$1\t\\n%\t"\\$2" .. . nr % 0 . rr F .\} .\" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .hy 0 .if n .na .\" .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). .\" Fear. Run. Save yourself. No user-serviceable parts. . \" fudge factors for nroff and troff .if n \{\ . ds #H 0 . ds #V .8m . ds #F .3m . ds #[ \f1 . ds #] \fP .\} .if t \{\ . ds #H ((1u-(\\\\n(.fu%2u))*.13m) . ds #V .6m . ds #F 0 . ds #[ \& . ds #] \& .\} . \" simple accents for nroff and troff .if n \{\ . ds ' \& . ds ` \& . ds ^ \& . ds , \& . ds ~ ~ . ds / .\} .if t \{\ . ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" . ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' . ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' . ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' . ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' . ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' .\} . \" troff and (daisy-wheel) nroff accents .ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' .ds 8 \h'\*(#H'\(*b\h'-\*(#H' .ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] .ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' .ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' .ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] .ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] .ds ae a\h'-(\w'a'u*4/10)'e .ds Ae A\h'-(\w'A'u*4/10)'E . \" corrections for vroff .if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' .if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' . \" for low resolution devices (crt and lpr) .if \n(.H>23 .if \n(.V>19 \ \{\ . ds : e . ds 8 ss . ds o a . ds d- d\h'-1'\(ga . ds D- D\h'-1'\(hy . ds th \o'bp' . ds Th \o'LP' . ds ae ae . ds Ae AE .\} .rm #[ #] #H #V #F C .\" ======================================================================== .\" .IX Title "DISTRIB.PATS 5" .TH DISTRIB.PATS 5 "2008-04-06" "INN 2.4.5" "InterNetNews Documentation" .SH "NAME" distrib.pats \- Default values for the Distribution header .SH "DESCRIPTION" .IX Header "DESCRIPTION" The file \fIpathetc\fR/distrib.pats is used by \fBnnrpd\fR to determine the default value of the Distribution header. Blank lines and lines beginning with a number sign (\f(CW\*(C`#\*(C'\fR) are ignored. All other lines consist of three fields separated by a colon: .PP .Vb 1 \& :: .Ve .PP The first field is the weight to assign to this match. If a newsgroup matches multiple lines, the line with the highest weight is used. This should be an arbitrary integer greater than zero. The order of lines in the file is only important if groups have equal weight (in which case, the first matching line will be used). .PP The second field is either the name of a newsgroup or a \fIuwildmat\fR\|(3)\-style pattern to specify a set of newsgroups. .PP The third field is the value that should be used for the Distribution header of a posted article, if this line was picked as the best match and no Distribution header was supplied by the user. It can be an empty string, specifying that no Distribution header should be added. .PP When a post is received by \fBnnrpd\fR that does not already contain a Distribution header, each newsgroup to which an article is posted will be checked against this file in turn, and the matching line with the highest weight will be used as the value of the Distribution header. If no lines match, or if the matching line has an empty string for its third field, no header will be added. .SH "HISTORY" .IX Header "HISTORY" Written by Rich \f(CW$alz\fR for InterNetNews. Converted to \&\s-1POD\s0 by Russ Allbery . .PP $Id: distrib.pats.5 7880 2008-06-16 20:37:13Z iulius $ .SH "SEE ALSO" .IX Header "SEE ALSO" \&\fIinn.conf\fR\|(5), \fInnrpd\fR\|(8), \fIuwildmat\fR\|(3)
|
__label__pos
| 0.586287 |
all 134 comments
[–]AThousandTimesThis 76 points77 points (89 children)
sorry, this has been archived and can no longer be voted on
The Turing Machine is the de-facto model and operating theory behind theoretical computer science.
[–]wbyte[S] 12 points13 points (65 children)
sorry, this has been archived and can no longer be voted on
Thanks. Is this generally accepted and unspoken or is it stated in texts which I could cite if I wanted to convince others?
[–]cstheoryphd 32 points33 points (64 children)
sorry, this has been archived and can no longer be voted on
Yes, generally accepted, oh, and Universal Turing Machine to be more specific. Most people wouldn't consider a watch to be a computer, though it is technically a Turing machine. The difference is that a UTM can simulate any other TM.
Source: Page 15 of this book gives a definition of a computer as consisting of five parts: input, output, memory, datapath, and control. If you think about it, those are parts of a UTM. The control is the states of the UTM, the input and output are on the tape, as is the memory and the datapath. This may seem like cheating, but the same disk in your computer stores programs and data (both input and output). http://www.amazon.com/Computer-Organization-Design-Third-Edition/dp/1558606041/ref=cm_lmf_tit_7
http://en.wikipedia.org/wiki/Universal_Turing_machine
There, now a theoretical computer science doctorate told you.
[–]wbyte[S] 7 points8 points (53 children)
sorry, this has been archived and can no longer be voted on
So computer science can be thought of as the science of Universal Turing Machines without losing or gaining any meaning?
[–]RankWeis 19 points20 points (24 children)
sorry, this has been archived and can no longer be voted on
I've always thought the name of Computer Science is a bit wrong. I much prefer the term computING science. Calling it the "science of UTM's" is actually saying the same thing - because all a Turing machine does is calculate an output to a given input.
What we learn in universities is how to come up with algorithms, their speeds, positives and negatives, how to come up with heuristics, how to create various automota, etc. But it all comes down to the science of computing something.
[–]myle 3 points4 points (3 children)
sorry, this has been archived and can no longer be voted on
Dijkstra agrees.
[–]UncleMeat 7 points8 points (2 children)
sorry, this has been archived and can no longer be voted on
Dudes love that quote, but I don't think the boundary between CS and actual machines is as clear as Dijkstra claims. I'll give an example.
Power usage is a huge problem today. Mobile devices are hugely prevalent and are getting more powerful, but battery technology has not improved much. Wouldn't it be great if we had a way of measuring the "power complexity" of an algorithm? It wouldn't seem to match nicely with time or space complexity since it is more related to the density of expensive operations. It is pretty hard to argue that developing a method of finding the power complexity of an algorithm isn't Computer Science.
However, a UTM abstracts any notion of "expensive" operations away away, so we would need another model of computation that would allow us to do this. This model would have to be fundamentally connected to our real world implementations since power consumption is a physical property rather than an abstract mathematical one. So we have a problem that is clearly Computer Science that is inexorably tied to physical implementations of computing.
Dijkstra's quote is fun to say because it lets us feel superior to engineers, but I think that it is missing a lot of important subtlety.
[–]RankWeis 1 point2 points (1 child)
sorry, this has been archived and can no longer be voted on
Dijkstra's quote is fun to say because it lets us feel superior to engineers
I love to feel superior to engineers, could you link the quote?
[–]UncleMeat 2 points3 points (0 children)
sorry, this has been archived and can no longer be voted on
Computer science no more about computers than astronomy is about telescopes. Somewhat insightful and somewhat naive in my opinion.
[–]Redard 3 points4 points (6 children)
sorry, this has been archived and can no longer be voted on
In the first video of MIT's OpenCourseWare Lisp lessons, the instructor gave a definition of computer science that I like just a little more than computation science.
He made the analogy that when geometry was invented, they named it after the tools they used --tools for measuring the earth; geo means earth and metry means measurement-- while what they were actually studying was shapes and their relationships. Likewise, computers are the tools we use in computer science, but it's not really the computers we study. It's the study of process, and can be done with or without computers. Computers just happen to be what we use for processing.
[–]RankWeis 2 points3 points (5 children)
sorry, this has been archived and can no longer be voted on
Thanks for the response, that IS very interesting; It made me think about why I still don't like the term.
To me, everyone understands geometry. But people don't understand a degree in CompSci- instead they'll ask:
"fix my computer?"
"so like you learn JavaScript? Can you build my website?"
My favorite "oh, so you program? I always wanted to learn that, you think you could teach me?"
To which I responded "sure! I mean I went to school for three years to understand, but do you have 15 minutes?"
It's the perception of what computer science means that I dislike. Even if it's accurate and historical, it still misrepresents and i think trivializes my effort and time going to university.
[–]wretcheddawn 1 point2 points (4 children)
sorry, this has been archived and can no longer be voted on
My brother did this:
"I want to build a program to do X for linux. Can you help me?"
"Uh, sure." So I spend 3 hours teaching him about variables, types, and assigning things.
"So when do we get to do actual stuff?"
"Got to walk before you can run, bro." Nothing was ever mentioned about it again.
[–]RankWeis 2 points3 points (3 children)
sorry, this has been archived and can no longer be voted on
I read a story about some guy, very enthusiastically, coming up to a programmer and saying "I have a fantastic idea for a football game, can you help me learn to program so I can do it?"
So they start off the same way you do, halfway through the lesson he stops the instructor and says "You know...nevermind...I always thought it was kind of like 'draw football stadium. throw football....not all this stuff'" and just left.
[–]crwcomposer 3 points4 points (0 children)
sorry, this has been archived and can no longer be voted on
Ah yes, the classic drawFootballStadium() from the C Standard Library.
[–]wretcheddawn 2 points3 points (1 child)
sorry, this has been archived and can no longer be voted on
Yup, my programming skill comes from years of theory in school, years of experience, personal study, and there's a ton that I don't understand. Until we invent the matrix, I don't think you're going to learn it in 2 hours.
[–]wbyte[S] 6 points7 points (5 children)
sorry, this has been archived and can no longer be voted on
Yes, I've often wondered if they called it computer science instead of computation science in order to attract more undergrad students.
[–][deleted] 5 points6 points (4 children)
sorry, this has been archived and can no longer be voted on
My dean (think thats the name. Boss over my CS program) explained it like this:
Computer Scientists use computers in the same way as astronomers use a telescope. You wouldnt say that the astronomer stody/work on telescopes. They figure out how the cosmos works.
The telescope and the computer are just tools.
A Computer scientist work/study computing. We use a computer as it makes most of the number crunching and tedious task a breeze.
Dijkstras apparantelly said that CS students shouldnt be allowed to touch a computer the first few years :)
[–]chromaticburst 4 points5 points (3 children)
sorry, this has been archived and can no longer be voted on
Don't know who your Dean is, but that's a very popular quote (misattributed to Dijkstra in most cases): "Computer science is no more about computers than astronomy is about telescopes". Apparently its origins are from SICP.
[–][deleted] 1 point2 points (2 children)
sorry, this has been archived and can no longer be voted on
Ohh cool! Haven't gotten through SICP yet :( Will do next semester though.
[–]NULLACCOUNT 1 point2 points (1 child)
sorry, this has been archived and can no longer be voted on
One of my favorite videos on the internet (although he doesn't use the exact quote he essentially says the same thing and a lot more).
SICP / What is Computer Science?
[–]stardek 2 points3 points (0 children)
sorry, this has been archived and can no longer be voted on
Some universities actually do call it computING science. University of Alberta and Simon Fraser University to name a couple.
[–]cjt09 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
Also, the Lambda Calculus is equivalent to a UTM. So you could also call it the Science of Lambda Calculus if you want to.
[–][deleted] (4 children)
sorry, this has been archived and can no longer be voted on
[deleted]
[–]teawreckshero 1 point2 points (2 children)
sorry, this has been archived and can no longer be voted on
That's not really an accurate definition of a Turing machine.
According to wikipedia:
"A universal Turing machine (UTM) is a Turing machine that can simulate an arbitrary Turing machine on arbitrary input." and "A Turing machine is a device that manipulates symbols on a strip of tape according to a table of rules."
So it's not even the input or output that defines a Turing machine, it's how it goes about accomplishing the task.
[–]crumblybutgood 2 points3 points (1 child)
sorry, this has been archived and can no longer be voted on
I disagree. The only way "how" matters is that Turing's machine is remarkably simple and intuitive. Otherwise the OP would be talking about how humans implement the lambda calculus. It's obvious that humans are functionally equivalent to Turing machines but perhaps not so much to other models of computation.
What defines a Turing machine is what it's able to output based upon its input.
[–]teawreckshero 3 points4 points (0 children)
sorry, this has been archived and can no longer be voted on
It's the "how" that makes it a Turing machine. Without the "limitless tape" and a table of instructions it is not a Turing machine.
"It's obvious that humans are functionally equivalent to Turing machines"
This isn't obvious to me. For something to be functionally equivalent it must accomplish that which being a Turing machine accomplishes, namely solving algorithms using tape and a instruction table.
It seems like you are defining this functional equivalence by claiming that the set of problems computable by a TM is equal to the set of problems computable by a human brain. While I think this is a separate claim from saying that a TM and a human are "functionally equivalent", I do not think this has been shown.
Care to elaborate? Maybe some reading material for me?
[–]epicwisdom -3 points-2 points (0 children)
sorry, this has been archived and can no longer be voted on
Turing*
Also, though a human could be considered a Turing machine, in practice our brains do not work that way, and can only work as a very restricted one if we specifically try to.
[–]shimei 4 points5 points (3 children)
sorry, this has been archived and can no longer be voted on
That statement loses perspective of the field as a whole. First of all, computer scientists do not always work in one model of computation. There is a lot to be gained from restricting your notion of computation. For example, regular expressions are really useful because they are easier to reason about. There are programming languages that are not Turing-complete: ACL2, Agda, Coq (though these are all theorem proving languages).
Secondly, there are many sub-fields of computer science which are either oblivious to the underlying model of computation (e.g., HCI, Health Informatics, and others) or fields that choose the actual machine as their model (e.g., Systems, OS). Yet others like Programming Languages have adopted other models (e.g., the Lambda calculus, object calculi, combinatory calculi, etc.) as their principal model.
[–]com2kid 0 points1 point (2 children)
sorry, this has been archived and can no longer be voted on
Yet others like Programming Languages have adopted other models (e.g., the [4] Lambda calculus, object calculi, combinatory calculi, etc.) as their principal model.
Those models are all equivalent in power (or in some cases less powerful) than the UTM model we all know and love. Indeed, they are just different languages for stating the same thing, some being more useful for certain problem sets than others.
[–]shimei 1 point2 points (1 child)
sorry, this has been archived and can no longer be voted on
Equivalent yes, but it's easier to reason about the lambda calculus when you're working with a functional programming language. Similarly with OO languages and object calculi, and so on. (we're just agreeing here, but just stating this for the benefit of others)
[–]com2kid 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
Equivalent yes, but it's easier to reason about the lambda calculus when you're working with a functional programming language. Similarly with OO languages and object calculi, and so on. (we're just agreeing here, but just stating this for the benefit of others)
Yup, they are all just different mind sets to approach the same problem. Some problems are easier to reason about if you drop into a certain mental configuration and hope the compiler/interpreter/jitter takes care of the rest. :)
Of course realizing that one can model a problem out in functional terms and then go and implement it in C++ is also a very valuable skill (and likely more valuable than knowing how to just apply a given problem solving techniques only in languages designed for them).
[–]level1 3 points4 points (16 children)
sorry, this has been archived and can no longer be voted on
Complexity theory, a branch of CompSci, spends a lot of time discussing other abstract machines. Some of the machines discussed are more powerful than a (deterministic) UTM, and some of them are less powerful. Complexity theory is concerned with how to determine what the limits of a particular abstract machine are.
Basically UTM is equivalent to the kind of computer that is built in the real world. The more powerful abstract machines are hypothetical, while the less powerful abstract machines are similar to parts of computers such as individual circuits.
[–]wbyte[S] 1 point2 points (12 children)
sorry, this has been archived and can no longer be voted on
Hmm the plot thickens. With that in mind, would you have a broader definition of a computer, or would you say that the machines outside of the UTM model shouldn't be classed as computers?
[–]level1 7 points8 points (10 children)
sorry, this has been archived and can no longer be voted on
Well, I think if you want to be precise relative to complexity theory, you should just adopt the terms of complexity theory:
• P or BPP* ~= desktops, supercomputers, smartphones
• NP, EXP, NEXP, R, RE, ALL ~= computers that are better than could exist in the real world
• BQP ~= Quantum Computers
• L, NL, NC, TC0 , AC0 ~= circuits or calculators (but not programmable calculators, that would be P or BPP)
If you don't care about being precise, I would suggest this simplified hierarchy:
• Programmable computers
• Calculators
• Rocks
[–]UncleMeat 6 points7 points (2 children)
sorry, this has been archived and can no longer be voted on
These are not classes of computation. They are classes of problems. EXP is the set of all languages that can be decided in exponential time by a TM, for example. Some of these sets are based on different computational models, like NP, but any computer can solve any problem from these classes. Non deterministic machines may be faster, but they cannot solve more problems that traditional machines.
[–]level1 0 points1 point (1 child)
sorry, this has been archived and can no longer be voted on
Thanks for the clarification. I am careless when I use terms to refer to problems and machines interchangeably. When I said "P or BPP ~= desktops, supercomputers, smartphones" what I meant was that P or BPP are sets of problems that are, generally speaking, tractable on computers that can be built in this universe. Of course, there are P problems which are too big to solve, and NP problems which can be solved quickly; it all depends on the size of the problem.
[–]UncleMeat 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
I still think that this is a misnomer. As long as the Church Turing thesis holds, no problem in EXP will be tractable on any classical computational model. It has nothing to do with the physical limitations of the universe. Even if you make your computer a trillion times faster, it still doesn't change the asymptotic running time of the algorithm that you use.
Of course, there are P problems which are too big to solve, and NP problems which can be solved quickly
This is also not precisely accurate. I am only making a big deal about this since this topic is touching on what is means to compute so getting our definitions right is important. A problem in P (or any complexity class) is a language (a set of strings) that can be decided by some algorithm in some asymptotic running time. In order to "decide" that problem you must be able to identify if an input string belongs in the language. This means that there are no "hard" problems in P and no "easy" problems in NP in terms of asymptotic running time.
There are hard and easy instances of problems. For example, deciding if the set {0} is in the subset sum language (contains a subset of integers that sum to 0) since the size of the set is small. But the subset sum problem is still hard. What you should have said was "there are instances of problems in P that take more clock time to decide than some instances of problems in NP". There are no problems that are in P that are harder than any problems that are in NP and also not in P.
This sort of hangup confuses a lot of students because they see something like a TSP instance that has an obvious solution and wonder why we say that TSP is a hard problem.
[–]tryx 3 points4 points (6 children)
sorry, this has been archived and can no longer be voted on
If you want to be incredibly pointlessly pedantic, the only computers that we can actually build in the real world, are exceptionally complex FSA. Anything else is physically out of the reach of classical computing. Quantum computing could probably break out of that, but I am not familiar enough with it.
[–]hvidgaard 0 points1 point (3 children)
sorry, this has been archived and can no longer be voted on
Quantum computing could probably break out of that, but I am not familiar enough with it.
If you accept the hypothesis, that there is a limited number of particles in the universe, you would have to find a way to store an infinite amount of information with a single particle, for any model to be able to build a true UTM.
[–]tryx 0 points1 point (2 children)
sorry, this has been archived and can no longer be voted on
But perhaps it can be more powerful than simply a FSA, was the point I was making. It obviously can't be a complete UTM.
[–]level1 0 points1 point (1 child)
sorry, this has been archived and can no longer be voted on
As long as your problem takes less memory to solve than, let's say, 20GB of ram, then FSAs and UTMs are equivalent. Once the problem size exceeds the memory capacity of the device then there is a significant difference.
[–]hvidgaard 2 points3 points (0 children)
sorry, this has been archived and can no longer be voted on
I think his point is that we cannot actual build a true UTM, only a tape restricted UTM, which is equivalent to a FA. We just use TMs because it's much easier to reason with and we assume that we can have enough memory to solve our problems.
[–]Coffee2theorems 3 points4 points (0 children)
sorry, this has been archived and can no longer be voted on
would you say that the machines outside of the UTM model shouldn't be classed as computers?
I'd say they aren't computers, but hypercomputers. Hypercomputation is stuff like a Turing machine coupled with a magic oracle solving the Halting Problem (maybe it's got God's phone number). These are studied to some extent, and I'd say that their study is a part of computer science, at least to the extent that it provides some context to the power of Turing machines. If you proceeded to study these very deeply just for the heck of it, then I'd say that it's not computer science anymore but mathematics.
Hypercomputation is purely theoretical. Nothing we have observed suggests that it would be possible in the universe we live in (see Church-Turing thesis), and people who believe it is possible are usually cranks (although some non-cranks, notably Penrose, believe that the human mind hypercomputes). In particular, quantum computers cannot hypercompute.
[–]qkdhfjdjdhd 0 points1 point (2 children)
sorry, this has been archived and can no longer be voted on
Wait. The UTM is equivalent to the kind of computer built in the real world?
The computers built in the real world are finite physical devices.
[–]level1 0 points1 point (1 child)
sorry, this has been archived and can no longer be voted on
Computers today are equivalent to Turing Machines that have a limited amount of tape, but as long as you only want to solve problems that are small enough there is no difference.
[–]qkdhfjdjdhd 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
But a turing machine is by definition possessed of an infinite tape.
[–][deleted] 1 point2 points (2 children)
sorry, this has been archived and can no longer be voted on
That might give people the wrong idea, though. It's not as though most computer scientists sit around all day writing out instructions about jostling a head around or proving properties of UTMs. At least not at that level of abstraction.
[–]wbyte[S] 0 points1 point (1 child)
sorry, this has been archived and can no longer be voted on
Well indeed, I wasn't suggesting we rename computer science :)
[–]epicwisdom 2 points3 points (0 children)
sorry, this has been archived and can no longer be voted on
For all intents and purposes, the basic function of computer science is to study computers. That's about as meaningful and accurate as the name can be for people unfamiliar with CS.
[–]DrPetrovich 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
almost. sometimes they consider interesting but less-than-universal machines, such as Finite Automata
[–]rtkwe 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
The point of Turing Machines is that ANY program/computer of any complexity can be run on a UTM. It abstracts away the differences in architectures/languages.
[–]SanityInAnarchy 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
...probably. Mostly.
Universal Turing Machines are the most interesting things, because if you can show that a UTM can be simulated on some bit of hardware H, and similarly, an H could be simulated on a UTM, then you've shown that every problem in one can be solved in the other.
Which means, theoretically, since certain artificial DNA constructs are Turing-complete, you could (theoretically) run Windows on DNA. Practically, we're a long way off, mostly because of error rates and because CMOS technology is so damned good.
But there's also a set of related, useful concepts.
Finite State Machines, for example, are not equivalent to UTMs. They're a subset, but they're a subset that has very obvious and fast hardware implementations -- if you can express something as an FSM, there's a very straightforward way to turn that FSM into transistors.
My personal favorite result here is that FSMs are equivalent to regular expressions, and that XML is not a regular language. That is, there is no regular expression you can build that will parse XML properly.
But in any case, there are several things like this which are useful fields of study in their own right. The watch may not be a UTM, but it may well be something computer science would be interested in.
Still, a UTM is kind of an upper bound here. The Church-Turing thesis pretty much says that all computation that can be carried out by any machine is Turing-computable... I think. I'd love to know if that's incomplete, or if there are exceptions.
[–]cstheoryphd 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
Yes. As of now, with the caveat that it is an open question whether a quantum computer will invalidate the complexity-theoretic church-turing thesis, (but it still won't invalidate the original one, since a QM can be simulated albeit slowly by a UTM): http://en.wikipedia.org/wiki/Church-Turing_thesis
[–]wbyte[S] 0 points1 point (7 children)
sorry, this has been archived and can no longer be voted on
(Second reply after your edit adding the source.) Thanks for that. I guess by this definition, the claim that the Antikythera Mechanism is a computer is accurate after all. I might have just lost a bet.
[–]JimH10 2 points3 points (5 children)
sorry, this has been archived and can no longer be voted on
Depends on your bet.
If you bet this is not a "computer" then you lose. It computes.
If you bet something more sophisticated about it not being a general-purpose computer, then you win.
I'll bet you lose. :-)
Edit: added the two "not"s because otherwise it didn't say what it meant.
[–]wbyte[S] 3 points4 points (0 children)
sorry, this has been archived and can no longer be voted on
On one hand, I lost. On the other hand, I won, because I learnt a hell of a lot from starting this discussion this evening :)
[–]Coffee2theorems 0 points1 point (3 children)
sorry, this has been archived and can no longer be voted on
"Computer" usually means a general-purpose computer. If a device that shows you astronomical positions when you turn a crank is a "computer", then one might argue that a rock that shows you a parabola when you throw it is also a "computer". Or less extremely, take a four-function calculator. Nobody would ever call one a "computer", even though it computes. Nor is a kaleidoscope, which computes fractal-like patterns, a computer.
FWIW, Wikipedia also agrees:
A computer is a general purpose device that can be programmed to carry out a finite set of arithmetic or logical operations. Since a sequence of operations can be readily changed, the computer can solve more than one kind of problem.
[–]JimH10 0 points1 point (2 children)
sorry, this has been archived and can no longer be voted on
"Computer" usually means a general-purpose computer.
I don't agree. For example, that is not the historical meaning and that device is obviously historical. In any event, mirriam-webster.com says this.
: one that computes; specifically : a programmable usually electronic device that can store, retrieve, and process data
My understanding of the device is that it is an analog computer; that you store data into it by entering the data, process the data by turning a crank, and then retrieve the results by looking at the dial.
[–]cstheoryphd -1 points0 points (1 child)
sorry, this has been archived and can no longer be voted on
My understanding is that the mechanism essentially hard-codes the "program" and all you have control over is the input, from which it generates the output. A general-purpose computer, even according to your MW definition, is programmable, which that thing was not, so I would say he most likely won the bet, depending on the parameters of it.
[–]JimH10 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
The bet, as stated was whether this was a computer. OP did not state that the bet was whether this was a general purpose computer, or Turing-equivalent, or any such thing. So, as stated, OP loses.
[–]cstheoryphd 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
I doubt the Anikythera Mechanim can be made to simulate a UTM. A turing machine can simulate it, but it can't simulate a UTM. In any case it can't write data, so it's not even a TM.
[–][deleted] (1 child)
sorry, this has been archived and can no longer be voted on
[deleted]
[–]cstheoryphd 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
What I meant is that a watch, like an antikythera mechanism, could be simulated by a particular Turing Machine, but is not itself a Universal Turing Machine. Think of a Turing Machine as a computer which can only run one program (it is hard-coded in the hardware). It takes input (the stem) and produces output (on the face). Sorry for the confusion.
[–]wibbly-wobbly 12 points13 points (3 children)
sorry, this has been archived and can no longer be voted on
Except where weaker automata, such as push-down automata, are studied, or other formalizations, such as the lambda calculus and mu-recursive functions are used.
[–]ReinH 2 points3 points (2 children)
sorry, this has been archived and can no longer be voted on
Lambda calculus (as formulated by Church) has exactly the same expressive power as a Turing Machine, a fact that Turing himself proved.
[–]wibbly-wobbly 1 point2 points (1 child)
sorry, this has been archived and can no longer be voted on
Indeed! It is one of the "other formalizations" I mentioned. However, push-down automata and finite state machines are less powerful, and are subject to study in computer science.
[–]ReinH 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
Turing's history with Church is actually quite fascinating.
[–]ixampl 14 points15 points (17 children)
sorry, this has been archived and can no longer be voted on
The Turing machine is only a (as in one of many) model and operating theory.
It's still too specific vague to be used as the definition of "computer". This answer just says: I'm not going to define what a computer is, but here's the de-facto model of computation. What I'm trying to say is: "a model of computation" is not the same as "a computer".
See for instance Biocomputers.
EDIT: Clarification.
[–]cstheoryphd 4 points5 points (7 children)
sorry, this has been archived and can no longer be voted on
True but others are generally considered to be Turing-equivalent per the Church-Turing thesis (note: not a scientific theory nor a mathematical theorem, just a generally accepted idea). A noted exception is the quantum computer, which is considered to be equivalent to an exponential version of a Turing machine, but with errors. Edit: Biocomputers are most definitely Turing-equivalent; there are just a lot of them and they can perform relatively efficiently. Whether quantum computers can really work remains to be seen.
[–]ixampl 5 points6 points (2 children)
sorry, this has been archived and can no longer be voted on
Biocomputers are most definitely Turing-equivalent; there are just a lot of them and they can perform relatively efficiently. Whether quantum computers can really work remains to be seen.
Yes, they are Turing-equivalent.
But OP asked for a general definition of "computer". So, is the answer: "everything that can emulate the workings of a Turing machine"? Since the Turing machine is only a model, we still haven't defined what a computer actually does, or how it does whatever it does. Maybe we don't want to define that. That's actually a good idea, I think. But just saying "The Turing Machine is the de-facto model and operating theory behind theoretical computer science."(AThousandTimesThis) does not really answer OPs question.
EDIT: The definition of a computer from that book you gave in this comment seems to be of a rather technical, specific nature. It is a definition, but I'm not sure whether it's general enough. Anyway, it seems OP was merely asking to figure out whether he lost a bet or not, and I guess he figured it out.
[–]wbyte[S] 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
OP was merely asking to figure out whether he lost a bet or not
It was just a figure of speech, really. My friends and I were discussing whether the Antikythera Mechanism was really a computer, as claimed in the media, and I said that it wasn't, but I couldn't quite back up my claim so I put the question to /r/compsci and, having been convinced by /u/cstheoryphd that a computer is a thing which satisfies the UTM model, I changed my stance.
Edit to add: The main thing which convinced me of this was the Church-Turing thesis.
[–]cstheoryphd -2 points-1 points (0 children)
sorry, this has been archived and can no longer be voted on
A computer is defined as a machine that can simulate a Universal Turing Machine. Once you have that, all else follows, and all is equivalent. The referred definition is certainly provably general enough, because such a machine can simulate a UTM, and that is all that is required, since a UTM can simulate anything else.
[–]wibbly-wobbly 3 points4 points (1 child)
sorry, this has been archived and can no longer be voted on
Church-Turing isn't about whether already existing models are Turing equivalent, it's about whether there CAN BE any models that are greater than Turing. (It states that there are none.)
However, mu-recursive functions and lambda calculus, to name just two, are PROVABLY equivalent to Turing machines when considering partial N->N functions.
[–]cstheoryphd 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
True and true.
[–]JamesCole 0 points1 point (1 child)
sorry, this has been archived and can no longer be voted on
Think about what that equivalence means.
If there's a set of computational devices/models that are all "Turing equivalent" that means that they're all equivalent. Any one can be used to perform the same computation as any of the other ones.
TMs are historically significant, and are useful because of their simplicity, but they are no "more" computation than any other equivalent model. It's just a convention that this equivalence is labelled as "Turing equivalence".
[–]cstheoryphd 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
Well I guess it depends on for what purpose you are defining a computer. He wanted to know a definition for computer science, not for engineering or whatever. Specifically the OP wanted to know if the antithikera mechanism was a computer, which is a theoretical question. To do theoretical work, one has to start from a single definition. If other things are equivalent to that definition, that fact must be proven by theorems, from their definitions. So we have to start from a single definition for computer, and then prove theorems such as that x is also a computer (by proving equivalence). This type of proof is what the OP was after.
[–]RichKatz 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
An important if philosophical point that brings up a major method used in computer science: the process of abstraction, though not unique to computer science.
First, consider the Platonic question: is there an ideal chair that is the essence or essential idea of a chair? Otherwise, how would we talk about an object and call it a chair if it did not have something essential that makes it a chair?
And is this idea of a chair also not a chair? This is echoed by Magritte and discussed by Foucault This is not a pipe and later by Craig Larman as explained by Crockett Harris Hopper
"Larman makes an excellent point about models right on the cover of his book Applying UML and Patterns. There is an illustration of two diagrams; the first is a photograph of a sailboat with the caption “This is not a sailboat”; the second is a UML class diagram containing the classes sailboat, mast, and hull and the same caption “This is not a sailboat.” Of course neither the photograph nor the UML diagram is an actual sailboat."
So within computational or computer science you can have classes of computers that are composed from the primordial or ideal computer that "extend" computer in function or attribute.
However, this particular process of abstraction and composition is far more than a simple philosophical exercise, but is in fact, an important topic within computer science itself.
[–]chocolate_ 0 points1 point (6 children)
sorry, this has been archived and can no longer be voted on
It's the only model that can be practically applied to modern computers.
Edit: Biocomputers can be described/simulated by Turing machines, as can anything that can be considered to be a computer. A computer is an implementation of a model of computation, and in theoretical computer science we use the Turing machine because it's the most universal. It allows us to discover the capabilities and limitations of computing.
[–]Fuco1337 6 points7 points (0 children)
sorry, this has been archived and can no longer be voted on
Defintiely not. A practical model is RAM. Turing machine is everything but practical.
[–]ixampl 2 points3 points (1 child)
sorry, this has been archived and can no longer be voted on
OP was not looking for a practical model, or a practical definition of a computer, or a definition of a practical computer. He/She asked for a general definition of what a computer actually is. What things are computers? What are the characteristics of a computer?
[–]wbyte[S] 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
Nailed it.
[–]wibbly-wobbly 2 points3 points (2 children)
sorry, this has been archived and can no longer be voted on
It's the only model that can be practically applied to modern computers.
Computer scientists use lambda calculus every day. Especially in programming languages and fields where programming languages have had high impact, such as some portions of the security field. It also has the advantage of being closely related to mathematical logic.
[–]chocolate_ 1 point2 points (1 child)
sorry, this has been archived and can no longer be voted on
Oh right. I overlooked lambda calculus because for some reason I never think of it in the same class as Turing machine. Thanks for mentioning that.
[–]wibbly-wobbly 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
Yep. Most computer scientists never bother to think about computational models, much less the lambda calculus, which isn't usually taught as a model of computation, but as a basis of programming languages. Nevertheless, it was originally designed to be a description of computation.
[–]lepuma 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
Yeah, but the "computer" part of computer science is definitely referring to a Turing Machine. I think this is what the OP wanted.
[–]ixampl 7 points8 points (23 children)
sorry, this has been archived and can no longer be voted on
Good question.
Wikipedia says: "A computer is a general purpose device that can be programmed to carry out a finite set of arithmetic or logical operations. Since a sequence of operations can be readily changed, the computer can solve more than one kind of problem."
Seems general enough at first glance but I hardly doubt that captures the concept of a (general) computer entirely.
[–]framy 5 points6 points (7 children)
sorry, this has been archived and can no longer be voted on
Wouldn't a human fall under this definition as well?
[–]nipuL 5 points6 points (0 children)
sorry, this has been archived and can no longer be voted on
Before that machine in front of you was invented, humans were computers, literally. It was their job to perform large calculations, usually for financial institutions, usually by hand. A small company called IBM started making machines to help automate some of the tedious work and reduce errors.
[–]ixampl 3 points4 points (4 children)
sorry, this has been archived and can no longer be voted on
Yes, it would. Is a human not a computer? If so, what exactly makes a human "not a computer"?
Others have defined "computer" as things that can do the things Turing machines can do (very popular in this submission). Well, humans can do that. They write down the definition and meticulously "calculate" state transitions, and write down "executions".
That's part of the question. Shall we exclude humans from the general definition of a computer?
[–]robotreader 0 points1 point (3 children)
sorry, this has been archived and can no longer be voted on
More precisely, other people have defined computers as things that are equivalent to turing machines. Humans can act as computers, but it's not at all clear that computers and humans are equivalent.
Look up strong AI for more info.
[–]ixampl 0 points1 point (2 children)
sorry, this has been archived and can no longer be voted on
I am familiar with that. I did not intend to say that they are equivalent.
By the definition on Wikipedia, humans fall (amongst others) into the category of computers. But of course that does not automatically imply the converse.
I guess my use of the verb "to be" made this statement too vague.
[–]robotreader 0 points1 point (1 child)
sorry, this has been archived and can no longer be voted on
What makes a human not a computer is that humans can do many things that computers can't(at the current state of the art, at any rate).
Definitions are, in general, both necessary and complete. That definition is a complete, concise, definition of a computer, but not of a human. Hence, either our understanding of computers is wrong, our understanding of humans is wrong, or they're different things. Currently, we believe they're different things. It would be more accurate to say that humans can do computing.
[–]ixampl 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
Please read my comment again. I thought I cleared up the misunderstanding and apologized for my sloppy expression.
Of course humans can do more things than computers can (or at least that's what we currently believe). I said humans can do everything that computers can (just not as fast) but I didn't say they cannot do more / are equivalent. "Falls in the category of" does not mean "is equivalent to".
Humans are mammals and they exhibit the properties of computers ... your home PC exhibits the computer properties but is not a mammal. Etc. Etc.
I did not define humans, I merely said (or wanted to say) that humans (ALSO) fulfil the requirements set for computers by the Wikipedia definition (save for them not being "devices").
As I said, I really thought my last comment made that obvious. Again, I apologize for my sloppy expression.
[–]sid0 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
Well, humans can obviously act like computers. A big open question in the philosophy of mind and CS is the converse.
[–]wbyte[S] 1 point2 points (3 children)
sorry, this has been archived and can no longer be voted on
Yes, I don't think a computer has to be a general purpose device to be a computer, does it? The hugely broad definition of "a thing which carries out a calculation" is the best fit in my mind, but I don't know if the computer science community as a whole has a similar or alternative definition, if any.
[–]ixampl 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
I don't know if the computer science community as a whole has a similar or alternative definition, if any
That's why you asked and I hope people with answers (i.e. not me) will come forward ;)
[–]mbateman 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
When asked what a computer is by a non-expert I always phrase it in terms of the difference between a calculator and a computer, that is the ability to look at the state of its own memory and make a decision.
[–]Fuco1337 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
A computer is something that can be programmed to compute any task. Anything else is not interesting. Otherwise, you could call "tossing stones to the pond" a computer, since it defintiely computes something.
Anyway, that's how CS people understand it, give or take.
[–]wwjd117 0 points1 point (1 child)
sorry, this has been archived and can no longer be voted on
One of my favorite examples: the tinkertoy computer. It might seem kind of like cheating, since it has to be rebuilt to perform different calculations, but that is how all machines thought of as computers began. You literally had to rewire computers to reprogram them.
The idea of computer can get a bit odd to people outside of computer science.
Some people argue whether the universe is a computer, or if it is merely a computation. These aren't crackpots either, but some of the best thinkers and theorists, from a variety of fields.
From the perspective of computer science, there are many things that perform computations that are not traditionally thought of as "machines", "calculators", or "computers".
Chemical reactions can be thought of as computations. Given the same inputs, the reactions produce the same answer. Change the inputs, different answer.
A sundial is an analog computer. It "calculates" the time given the input of sunlight. Slightly more useful is my watch, which calculates the correct time without regard to sunlight.
My brain is a computer, which sadly doesn't always give the same answer given the same set of inputs. Apparently, it is a little buggy.
[–]Initandur04 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
Apparently, it is a little buggy.
If I might rephrase: Apparently, the space of possible answers for a given set of inputs is so vast that its only efficient recourse is a collection of constantly refined, and thus changing, heuristic methods.
[–]chris-martin -1 points0 points (8 children)
sorry, this has been archived and can no longer be voted on
I think some notion of efficiency would be a useful addition to that description.
[–]ixampl 4 points5 points (6 children)
sorry, this has been archived and can no longer be voted on
I would disagree. Is a "___" (thing) that takes a year to (correctly) calculate "sqrt(x + 612 / 6) * 10" for a given input x not a computer? If it's not a computer, what is it?
EDIT: Well, taking the general definition I believe humans are computers, which is not that strange a thing IMO.
[–]chris-martin 0 points1 point (5 children)
sorry, this has been archived and can no longer be voted on
I'm not saying we can set hard limits on anything, but that computers are designed for efficiency. If you construct a mechanical turing machine, then yes, what it does is computation, but only in a uselessly reductionist sense. Useful for theory, but "computer" is not really a word that we use in theory very often. If we mean turing machine, we say turing machine. Computers are things that are designed to be used. This is connotational.
[–]ixampl 0 points1 point (4 children)
sorry, this has been archived and can no longer be voted on
First of all, are "computers" (a term which we still haven't defined for the sake of discussion) designed to be used? Why concentrate so much on practicability? OP wants to find out whether the term "computer" has ever been precisely defined.
Even assuming we are looking at practicability. Let's say we have a computer that is terribly inefficient (but correct), taking twice as long as it would take you to calculate by hand. Still, making it work for you instead of yourself saves you work / allows you to do other things in parallel. So it would be practical after all.
[–]chris-martin 0 points1 point (2 children)
sorry, this has been archived and can no longer be voted on
Let's look at space complexity, then, and perhaps my point will become more lucid.
I'm going to assume that you would agree that the phone/laptop/etc with which you are browsing Reddit is a computer. From the strict mathematical view of which you are so fond, then, we can conclude that computers are not turing machines and cannot solve general problems - because your device has a finite memory instead of an infinite tape, and is therefore nothing but a glorified regular expression parser.
To say that your device cannot solve general problems in the same way that an LED on a dimmer switch cannot solve general problems is, of course, a reduction to absurdity. It reasonable to call a laptop a computer because it is an approximation of a turing model. The state space is so phenomenally large that we can often conveniently forget its finite boundary.
And here's where we come back around to efficiency. Suppose the memory hardware encodes state as a unary, rather than binary, string. It still works - it's just far less efficient. Enough so that you can give up any hope of utilizing it for nontrivial computational tasks, and you can now feel the constraints of the space limitation such that you're now going to start thinking about this device as a finite state machine. You need "very large" memory to pretend that a device simulates a powerful computational model, and you need some consideration to efficiency to physically realize a large state space.
[–]ixampl -1 points0 points (1 child)
sorry, this has been archived and can no longer be voted on
From the strict mathematical view of which you are so fond
Am I?
[–]chris-martin 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
I don't know, did I miss something?
[–]Coffee2theorems -1 points0 points (0 children)
sorry, this has been archived and can no longer be voted on
Why concentrate so much on practicability?
Some philosophers have argued against the possibility of "strong AI" based on a thought experiment called Chinese room, which involves us imagining a non-Chinese-speaking human in a closed room manually emulating a computer algorithm that can understand Chinese, and then proceeds to claim that the computer (the "Chinese room") doesn't really understand Chinese because the human does not, it's just simulating the understanding of Chinese. It's obviously complete bollocks, but the question why is somewhat interesting, and therein comes the practicality part.
I rather like Radford Neal's criticism of the Chinese room thought experiment. The idea is that the argument is essentially: (1) the person does not understand Chinese, (2) any of the non-living pieces of the computer obviously don't understand Chinese, (3) the sum does not understand Chinese because "the conjunction of that person and bits of paper" 'obviously' doesn't. Neal essentially says that step (3) abuses the hospitality of the person who was asked to imagine that this thought experiment is possible in principle, because it applies everyday (pre-computer-era) intuition ('obviously') to a system that is far beyond the regime of its applicability, kind of like applying everyday intuition to the quantum world. In the pre-computer-era, such intuition is correct: the "Chinese room" does not understand Chinese, because the computation is simply not practical, and the Chinese room cannot exist. It is only in the modern era where AI like that becomes possible, and we have computers that play good Chess without a human inside (unlike mechanical Turk). It makes a qualitative difference. Imagine a future where we have AI that passes the Turing test with flying colors. It is a very different world from one without such AI, and you cannot do it "Chinese room"-style or even properly comprehend it based on such ideas, even though the Chinese room is a computer.
[–]wbyte[S] 2 points3 points (0 children)
sorry, this has been archived and can no longer be voted on
I don't think efficiency needs to be a part of any definition of a computer. It might help to explain why digital programmable computers are useful and ubiquitous but I think it's irrelevant in the fundamental definition of a computer.
[–]HelloAnnyong 2 points3 points (1 child)
sorry, this has been archived and can no longer be voted on
On Turing machines, from Scott Aaronson's wonderful lecture series:
In 1936, the word "computer" meant a person (usually a woman) whose job was to compute with pencil and paper. Turing wanted to show that, in principle, such a "computer" could be simulated by a machine. What would the machine look like? Well, it would have to able to write down its calculations somewhere. Since we don't really care about handwriting, font size, etc., it's easiest to imagine that the calculations are written on a sheet of paper divided into squares, with one symbol per square, and a finite number of possible symbols. Traditionally paper has two dimensions, but without loss of generality we can imagine a long, one-dimensional paper tape. How long? For the time being, we'll assume as long as we need.
What can the machine do? Well, clearly it has to be able to read symbols off the tape and modify them based on what it reads. We'll assume for simplicity that the machine reads only one symbol at a time. But in that case, it had better be able to move back and forth on the tape. It would also be nice if, once it's computed an answer, the machine can halt! But at any time, how does the machine decide which things to do? According to Turing, this decision should depend only on two pieces of information: (1) the symbol currently being read, and (2) the machine's current "internal configuration" or "state." Based on its internal state and the symbol currently being read, the machine should (1) write a new symbol in the current square, (2) move backwards or forwards one square, and (3) switch to a new state or halt.
Finally, since we want this machine to be physically realizable, the number of possible internal states should be finite. These are the only requirements.
Turing's first result is the existence of a "universal" machine: a machine whose job is to simulate any other machine described via symbols on the tape. In other words, universal programmable computers can exist. You don't have to build one machine for email, another for playing DVD's, another for Tomb Raider, and so on: you can build a single machine that simulates any of the other machines, by running different programs stored in memory.
It should be noted that a Turing machine isn't really a definition of what a computer "is". No computers we use today resemble a Turing machine in their mechanical operation. (Rather, the computers we use are generally Von Neumann architectures. Instead, a Turing machine defines (as far as we know) what physically-achievable computers are able to do. That is, as far as we know, any computer we build (whether using classical physics, quantum mechanics, or something else), can at most solve exactly the problems a Turing machine can and no others.
[–]wibbly-wobbly 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
Instead, a Turing machine defines (as far as we know) what physically-achievable computers are able to do.
It's a bit stronger than that. Turing machines describe (as far as we know) what an algorithm can do. Algorithm can be intuitively defined as a listing of steps.
The computers we have now are equivalent in power to Turing Machines.
[–][deleted] 21 points22 points (6 children)
sorry, this has been archived and can no longer be voted on
How is computter formed? How is computter form? How data get praccessed?
[–]dont_press_ctrl-W 5 points6 points (0 children)
sorry, this has been archived and can no longer be voted on
I'll have to upvote you just for that double t.
[–]lepuma -5 points-4 points (3 children)
sorry, this has been archived and can no longer be voted on
What?
[–]boot20 10 points11 points (2 children)
sorry, this has been archived and can no longer be voted on
I think it was a play on How is babby formed
[–]lepuma 3 points4 points (1 child)
sorry, this has been archived and can no longer be voted on
Thank you, that was fucking hilarious
[–][deleted] 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
You think that's funny? Try the Taylor Swift style song version!
[–]starcrap2 3 points4 points (0 children)
sorry, this has been archived and can no longer be voted on
Pragmatically, I think Wikipedia's definition works.
[–]oopsiedaisy 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
It is a collection of lights and switches and buttons and magnets, hooked up to a clock. There is a small pump inside next to a tank full of magic smoke, and when you push one of the buttons, a small cloud of magic smoke is released into the computing chamber, where powerful spinning magnets trigger a combustion reaction, leaving nothing behind but pure logic, which as you know, is negatively charged and water-soluble, thus the weaker, stationary magnets positioned at the bottom. Next to the condensation pan.
[–]xanatos1 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
Well in old timey days a Computer was someone whose whose job it was to perform the repetitive calculations required to compute such things as navigational tables, tide charts, and planetary positions for astronomical almanac.
[–]StealthSilver 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
I'd be interested to see the results if you were to x-post this in r/philosophy.
[–]suboptimus_prime 3 points4 points (3 children)
sorry, this has been archived and can no longer be voted on
Your question is very broad.. You need to be more specific. As far as I know, there is no "accepted scientific definition" of a computer. The word "computer" stems from the "to compute", meaning "to determine something by calculation".
By that definition, I believe it's the Abacus that's the earliest "computing machine" which was used first by the Mesopotamians to perform arithmetic. So really in a sense, computers aren't as rigidly defined as say.. cars, or refrigerators, since anything that has "the ability to compute" is considered a computer.
This might have raised more questions for you than it has answered :P can you be more specific?
[–]wbyte[S] 3 points4 points (2 children)
sorry, this has been archived and can no longer be voted on
Well this is how the question arose. The term is very broad, but since computer science is called computer science I figured there must be an accepted definition within the field.
[–]lepuma 1 point2 points (0 children)
sorry, this has been archived and can no longer be voted on
The "computer" part of computer science is basically referring to the Turing Machine.
[–]LookInTheDog -1 points0 points (0 children)
sorry, this has been archived and can no longer be voted on
So the thing about words...
The way I think about words is like this. If you mapped every thing (idea, object, etc) in the universe on a group of axes to represent all possible characteristics in n-space, some things would fall close together on multiple axes. The way we refer to a group of things that fall close to each other like that is to give them a word. So for example we have the word cat, which describes furry, four-footed creatures that meow.
The problem is that the group that this word defines is not actually very regularly shaped. If a cat loses a leg and only has 3, is it still a cat? Sure. If you shave the cat and it's no longer furry, is it still a cat? Of course. If a dog has malformed vocal cords that make it sound like it's meowing, does it become a cat? Nope. Etc. So the word itself describes a region with lots of concaves and fingers sticking out - a very irregular shape around this cluster of objects.
When you start taking that word and trying to give it a simple definition - like "has four legs and is furry and meows" - what you're really doing is creating a shape that's very regular. So you're taking this amoeba-shaped object and putting a circle (sphere) or square (cube) around it. So obviously there will be things in the circle that are outside the actual shape, or things in the shape that are outside the circle (or both). The definition is less exact than the word itself, because the word is complex and the definition is simple.
So enough about cats and back to computers. When you ask for a definition of a computer, you're asking for a simple definition of a complex term. Your options are basically to either give a very broad definition that encompasses everything that we think about as computers as well as some other things that we don't generally think of computers (e.g. "something that computes" could apply to a bacteria in some cases), or you have a narrower definition that misses out on some things we do call computers (e.g. "can solve more than one kind of problem" might exclude say the computers that are in a paint robot which only solves the problem of painting a car), or you get an accurate definition which has scores upon scores of caveats and exceptions and additions, but accurately represents the shape of the word as we use it.
So pragmatically, my question is this: why do you want to know the definition? If a tree falls in the forest, does it make a sound? If you define sound as "auditory processing in the brain" then no, if you define sound as "vibrations in the air" then yes. But why do you want to know? If you're wondering if the leaves in nearby trees will shake from the vibrations caused by the tree falling, then you've already answered your question without worrying about the definition of "sound."
If you want to know what something does (does it do calculations? Can it process data? etc.) then answer that question. If you're asking what computer scientists study, then go look at what they study, you don't need a definition of computer to find that out. If you're trying to win a bet, then define it however you want to win the bet. (But in the future, make bets that have an expectation in reality that you can verify.)
TL;DR Depends on why you want to know.
[–]Crogers16 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
I was always told it was any automatic system that performs a desired oucome. Is this true?
[–][deleted] 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
There are many defintions. Very liberal definitions to very narrow definitions.
• Everything that changes is a computer. This is the most relaxed and abstract definition of a computer.
• An artificial arrangement of things which changes is also a computer.
• An artificial arrangement of things which changes like anything else is also a computer.
• An artificial arrangement of things which, with with minimal rearrangement, can change like anything else is also a computer.
Here is the definition of Computer Science.
[–]rincewind123 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
A professor at our university said that a computer is a machine that can compute everything that is computable.
[–]nofries -1 points0 points (1 child)
sorry, this has been archived and can no longer be voted on
[–]happysri 6 points7 points (0 children)
sorry, this has been archived and can no longer be voted on
Von Neumann architecture does not always a computer make.
[–]Flau1990 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
Well, i like the german term ( "Informatik" = procession of Information ) better anyway. I guess the problem is just the wrong choice of words, not the definition.
[–]AerialAmphibian 0 points1 point (0 children)
sorry, this has been archived and can no longer be voted on
The "practical" definition I got in my computer science classes was that a computer consists, at minimum, of a processor and storage (memory). The details were left up to the designer to decide. It could be mechanical, electro-mechanical, electronic, optical, or more recently quantum.
Anything attached to the device that wasn't either a CPU or memory was considered an optional peripheral.
|
__label__pos
| 0.682509 |
Date time picker format
Good day,
In UI Builder i have a date time picker with custom format and Date Only Picker Mode.
image
In the table the result will give the date the user has selected, but it will also show the time the user has selected that date. The field is a datetime field.
image
Is it possible to get only the date in this field? Or is there a way to always set the time to 12:00:00.
I am reformatting this date into another format so the user sees the date only.
But when the user is registering in the night till 01.00 the result shows the date minus one day.
@Michel_Loriaux ,
To clarify situation.
Could you please check what timestamp stored in the database by retrieving the record using “REST Console” in “Data Service” section?
Regards, Andriy
See the below result:
image
You can set the time element in your logic. By default, the system will assign the current time (on the UI side).
Regarding the following:
Does the data show minus one day in the database or in your UI?
Mark
Hi Mark,
This is what happens, in the first line the user has selected may 20th 2022 but he did it at 00:07:00.
Then it shows in the second column the day before. The three last registrations are OK because they are before 00:00
image
image
I do have a time add formula in the second column but i needed to do this to get the correct date in the second column:
image
How would i set the time element in my logic in the date time picker?
Hello @Michel_Loriaux
I’m trying to understand the main idea.
So, the question is with displaying a date in the DataBrowser?
In your formula, you’ve got 1 hour, what’s the purpose for that?
Have you tried to modify the date(timestamp) in the On Change Event for the DateTimePicker?
Btw, when you keep the date in the Datetime column it stores as a timestamp (including hours/minutes/seconds/milliseconds) and the same timestamp will look different for different time zones, for instance 00:00:00 in the EU is today, but in the US it’s yesterday
Correct, i am using the second column in order to be able to show it in a Data Table in the correct formatting.
image
The one hour time difference i added because of many incorrect dates in this field.
Can you explain how i can modify the date(timestamp) in the On Change Event for the DateTimePicker?
It depends on the format you need it in, here’s the simplest way:
UI Builder - ConsoleDemo - Backendless 2022-05-24 14-42-28
|
__label__pos
| 0.990505 |
0 Daumen
2,3k Aufrufe
Der Nenner eines Bruchs ist um 4 kleiner als der Zähler. Vermindert man den Nenner um 7, so verhält sich der Wert des alten Bruchs zu dem des neuen wie 4 zu 5. Wie lautet der ursprüngliche Bruch?
Avatar von
3 Antworten
0 Daumen
Ein Bruch hat die Form a/b.
Wir wissen folgendes:
(1) a = b-4
(2) (a/b)/(a/(b-7)) = 4/5
(2) lässt sich noch umformen zu:
(b-7)/b = 4/5
b -7 = 4/5 b
1/5 b = 7
b = 35
Also: a = 35-4 = 31
Der Bruch lautet also 31/35.
Avatar von 10 k
0 Daumen
Ansatz:
(x/(x - 4)) / (x/(x-4-7)) = 4 / 5
Kontrollösung
x = 39
Alter Bruch
39/35
Neuer bruch
39/28
Avatar von 483 k 🚀
...ganz lieben Dank für die schnellen Antworten an Mi und Mathecoach. Jetzt habe ich drei Ergebnisse:
Lösung habe ich mittlerweile gefunden - 39/35 -; was ist richtig? herzlichen Dank!
0 Daumen
Der Zähler ist x der Nenner ist x-4,
im neuen Bruch ist dr Zähler x und der Nenner x-4-7= x-11
$$ \begin{array} { l } { \frac { x } { x - 4 } : \frac { x } { x - 11 } = \frac { 4 } { 5 } } \\ { \frac { x } { x - 4 } · \frac { x - 11 } { x } = \frac { 4 } { 5 } } \\ { \frac { x - 11 } { x - 4 } = \frac { 4 } { 5 } } \end{array} \\ \begin{aligned} ( x - 11 ) * 5 & = 4 * ( x - 4 ) \\ 5 x - 55 & = 4 x - 16 \\ x & = 39 \end{aligned} $$
Somit ist der alte Bruch 39/35 der neue dann 39/28
Probe( 39/35):(39/28)=28/35=4/5
Avatar von 40 k
Ein anderes Problem?
Stell deine Frage
Willkommen bei der Mathelounge! Stell deine Frage einfach und kostenlos
x
Made by a lovely community
|
__label__pos
| 0.9994 |
Editing footnotes
This example demonstrates one way to implement something like footnotes in ProseMirror.
Footnotes seem like they should be inline nodes with content—they appear in between other inline content, but their content isn't really part of the textblock around them. Let's define them like this:
import {schema} from "prosemirror-schema-basic"
import {Schema} from "prosemirror-model"
const footnoteSpec = {
group: "inline",
content: "text*",
inline: true,
// This makes the view treat the node as a leaf, even though it
// technically has content
atom: true,
toDOM: () => ["footnote", 0],
parseDOM: [{tag: "footnote"}]
}
const footnoteSchema = new Schema({
nodes: schema.spec.nodes.addBefore("image", "footnote", footnoteSpec),
marks: schema.spec.marks
})
Inline nodes with content are not handled well by the library, at least not by default. You are required to write a node view for them, which somehow manages the way they appear in the editor.
So that's what we'll do. Footnotes in this example are drawn as numbers. In fact, they are just <footnote> nodes, and we'll rely on CSS to add the numbers.
import {StepMap} from "prosemirror-transform"
import {keymap} from "prosemirror-keymap"
import {undo, redo} from "prosemirror-history"
class FootnoteView {
constructor(node, view, getPos) {
// We'll need these later
this.node = node
this.outerView = view
this.getPos = getPos
// The node's representation in the editor (empty, for now)
this.dom = document.createElement("footnote")
// These are used when the footnote is selected
this.innerView = null
}
Only when the node view is selected does the user get to see and interact with its content (it'll be selected when the user ‘arrows’ onto it, because we set the atom property on the node spec). These two methods handle node selection and deselection the node view.
selectNode() {
this.dom.classList.add("ProseMirror-selectednode")
if (!this.innerView) this.open()
}
deselectNode() {
this.dom.classList.remove("ProseMirror-selectednode")
if (this.innerView) this.close()
}
What we'll do is pop up a little sub-editor, which is itself a ProseMirror view, with the node's content. Transactions in this sub-editor are handled specially, in the dispatchInner method.
Mod-z and y are bound to run undo and redo on the outer editor. We'll see in a moment why that works.
open() {
// Append a tooltip to the outer node
let tooltip = this.dom.appendChild(document.createElement("div"))
tooltip.className = "footnote-tooltip"
// And put a sub-ProseMirror into that
this.innerView = new EditorView(tooltip, {
// You can use any node as an editor document
state: EditorState.create({
doc: this.node,
plugins: [keymap({
"Mod-z": () => undo(this.outerView.state, this.outerView.dispatch),
"Mod-y": () => redo(this.outerView.state, this.outerView.dispatch)
})]
}),
// This is the magic part
dispatchTransaction: this.dispatchInner.bind(this),
handleDOMEvents: {
mousedown: () => {
// Kludge to prevent issues due to the fact that the whole
// footnote is node-selected (and thus DOM-selected) when
// the parent editor is focused.
if (this.outerView.hasFocus()) this.innerView.focus()
}
}
})
}
close() {
this.innerView.destroy()
this.innerView = null
this.dom.textContent = ""
}
What should happen when the content of the sub-editor changes? We could just take its content and reset the content of the footnote in the outer document to it, but that wouldn't play well with the undo history or collaborative editing.
A nicer approach is to simply apply the steps from the inner editor, with an appropriate offset, to the outer document.
We have to be careful to handle appended transactions, and to be able to handle updates from the outside editor without creating an infinite loop, the code also understands the transaction flag "fromOutside" and disables propagation when it's present.
dispatchInner(tr) {
let {state, transactions} = this.innerView.state.applyTransaction(tr)
this.innerView.updateState(state)
if (!tr.getMeta("fromOutside")) {
let outerTr = this.outerView.state.tr, offsetMap = StepMap.offset(this.getPos() + 1)
for (let i = 0; i < transactions.length; i++) {
let steps = transactions[i].steps
for (let j = 0; j < steps.length; j++)
outerTr.step(steps[j].map(offsetMap))
}
if (outerTr.docChanged) this.outerView.dispatch(outerTr)
}
}
To be able to cleanly handle updates from outside (for example through collaborative editing, or when the user undoes something, which is handled by the outer editor), the node view's update method carefully finds the difference between its current content and the content of the new node. It only replaces the changed part, in order to leave the cursor in place whenever possible.
update(node) {
if (!node.sameMarkup(this.node)) return false
this.node = node
if (this.innerView) {
let state = this.innerView.state
let start = node.content.findDiffStart(state.doc.content)
if (start != null) {
let {a: endA, b: endB} = node.content.findDiffEnd(state.doc.content)
let overlap = start - Math.min(endA, endB)
if (overlap > 0) { endA += overlap; endB += overlap }
this.innerView.dispatch(
state.tr
.replace(start, endB, node.slice(start, endA))
.setMeta("fromOutside", true))
}
}
return true
}
Finally, the nodeview has to handle destruction and queries about which events and mutations should be handled by the outer editor.
destroy() {
if (this.innerView) this.close()
}
stopEvent(event) {
return this.innerView && this.innerView.dom.contains(event.target)
}
ignoreMutation() { return true }
}
We can enable our schema and node view like this, to create an actual editor.
import {EditorState} from "prosemirror-state"
import {DOMParser} from "prosemirror-model"
import {EditorView} from "prosemirror-view"
import {exampleSetup} from "prosemirror-example-setup"
window.view = new EditorView(document.querySelector("#editor"), {
state: EditorState.create({
doc: DOMParser.fromSchema(footnoteSchema).parse(document.querySelector("#content")),
plugins: exampleSetup({schema: footnoteSchema, menuContent: menu.fullMenu})
}),
nodeViews: {
footnote(node, view, getPos) { return new FootnoteView(node, view, getPos) }
}
})
|
__label__pos
| 0.998952 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.